PageRenderTime 60ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 1ms

/components/synedit/synhighlightercss.pas

http://github.com/graemeg/lazarus
Pascal | 2161 lines | 1899 code | 214 blank | 48 comment | 191 complexity | 1495752305ee9075843862d627b04367 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, MPL-2.0-no-copyleft-exception 
    

  1. {-------------------------------------------------------------------------------
    2. 

  2. The contents of this file are subject to the Mozilla Public License
    3. 

  3. Version 1.1 (the "License"); you may not use this file except in compliance
    4. 

  4. with the License. You may obtain a copy of the License at
    5. 

  5. http://www.mozilla.org/MPL/
    6. 

  6. 

  7. Software distributed under the License is distributed on an "AS IS" basis,
    8. 

  8. WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
    9. 

  9. the specific language governing rights and limitations under the License.
    10. 

  10. 

  11. The Original Code is: SynHighlighterCSS.pas, released 2000-04-14.
    12. 

  12. The Original Code is based on the mwCSSSyn.pas file from the
    13. 

  13. mwEdit component suite by Martin Waldenburg and other developers, the Initial
    14. 

  14. Author of this file is Tony De Buys.
    15. 

  15. All Rights Reserved.
    16. 

  16. 

  17. Contributors to the SynEdit and mwEdit projects are listed in the
    18. 

  18. Contributors.txt file.
    19. 

  19. 

  20. Alternatively, the contents of this file may be used under the terms of the
    21. 

  21. GNU General Public License Version 2 or later (the "GPL"), in which case
    22. 

  22. the provisions of the GPL are applicable instead of those above.
    23. 

  23. If you wish to allow use of your version of this file only under the terms
    24. 

  24. of the GPL and not to allow others to use your version of this file
    25. 

  25. under the MPL, indicate your decision by deleting the provisions above and
    26. 

  26. replace them with the notice and other provisions required by the GPL.
    27. 

  27. If you do not delete the provisions above, a recipient may use your version
    28. 

  28. of this file under either the MPL or the GPL.
    29. 

  29. 

  30. $Id$
    31. 

  31. 

  32. You may retrieve the latest version of this file at the SynEdit home page,
    33. 

  33. located at http://SynEdit.SourceForge.net
    34. 

  34. 

  35. Known Issues:
    36. 

  36. -------------------------------------------------------------------------------}
    37. 

  37. {
    38. 

  38. @abstract(Provides a CSS syntax highlighter for SynEdit)
    39. 

  39. @author(Tony de Buys)
    40. 

  40. @created(1999)
    41. 

  41. @lastmod(2000-06-23)
    42. 

  42. The SynHighlighterCss unit provides SynEdit with a Cascading Style Sheets syntax highlighter.
    43. 

  43. Thanks to Martin Waldenburg.
    44. 

  44. }
    45. 

  45. unit SynHighlighterCss;
    46. 

  46. 

  47. {$I SynEdit.inc}
    48. 

  48. 

  49. interface
    50. 

  50. 

  51. uses
    52. 

  52. 

  53.   SysUtils, Classes,
    54. 

  54.   LCLIntf, LCLType,
    55. 

  55.   Controls, Graphics,
    56. 

  56.   SynEditTypes, SynEditHighlighter;
    57. 

  57. 

  58. type
    59. 

  59.   TtkTokenKind = (tkComment, tkIdentifier, tkKey, tkNull, tkNumber, tkSpace,
    60. 

  60.     tkString, tkSymbol, tkMeasurementUnit, tkSelector, tkUnknown);
    61. 

  61. 

  62.   TRangeState = (rsCStyle, rsInDeclarationBlock);
    63. 

  63.   TRangeStates = set of TRangeState;
    64. 

  64. 

  65.   TProcTableProc = procedure of object;
    66. 

  66. 

  67.   PIdentFuncTableFunc = ^TIdentFuncTableFunc;
    68. 

  68.   TIdentFuncTableFunc = function: TtkTokenKind of object;
    69. 

  69. 

  70. type
    71. 

  71. 

  72.   { TSynCssSyn }
    73. 

  73. 

  74.   TSynCssSyn = class(TSynCustomHighlighter)
    75. 

  75.   private
    76. 

  76.     fRange: TRangeStates;
    77. 

  77.     fLine: PChar;
    78. 

  78.     fLineNumber: Integer;
    79. 

  79.     fProcTable: array[#0..#255] of TProcTableProc;
    80. 

  80.     Run: LongInt;
    81. 

  81.     fStringLen: Integer;
    82. 

  82.     fToIdent: PChar;
    83. 

  83.     fTokenPos: Integer;
    84. 

  84.     FTokenID: TtkTokenKind;
    85. 

  85.     fIdentFuncTable: array[0..275] of TIdentFuncTableFunc;
    86. 

  86.     fCommentAttri: TSynHighlighterAttributes;
    87. 

  87.     fIdentifierAttri: TSynHighlighterAttributes;
    88. 

  88.     fKeyAttri: TSynHighlighterAttributes;
    89. 

  89.     fNumberAttri: TSynHighlighterAttributes;
    90. 

  90.     fSpaceAttri: TSynHighlighterAttributes;
    91. 

  91.     fStringAttri: TSynHighlighterAttributes;
    92. 

  92.     fSymbolAttri: TSynHighlighterAttributes;
    93. 

  93.     fMeasurementUnitAttri: TSynHighlighterAttributes;
    94. 

  94.     fSelectorAttri: TSynHighlighterAttributes;
    95. 

  95.     function KeyHash(ToHash: PChar): Integer;
    96. 

  96.     function KeyComp(const aKey: String): Boolean;
    97. 

  97.     function Func16: TtkTokenKind;
    98. 

  98.     function Func18: TtkTokenKind;
    99. 

  99.     function Func19: TtkTokenKind;
    100. 

  100.     function Func23: TtkTokenKind;
    101. 

  101.     function Func24: TtkTokenKind;    
    102. 

  102.     function Func26: TtkTokenKind;
    103. 

  103.     function Func29: TtkTokenKind;
    104. 

  104.     function Func30: TtkTokenKind;
    105. 

  105.     function Func32: TtkTokenKind;
    106. 

  106.     function Func34: TtkTokenKind;            
    107. 

  107.     function Func36: TtkTokenKind;
    108. 

  108.     function Func39: TtkTokenKind;
    109. 

  109.     function Func40: TtkTokenKind;
    110. 

  110.     function Func41: TtkTokenKind;
    111. 

  111.     function Func43: TtkTokenKind;
    112. 

  112.     function Func45: TtkTokenKind;
    113. 

  113.     function Func47: TtkTokenKind;
    114. 

  114.     function Func51: TtkTokenKind;
    115. 

  115.     function Func52: TtkTokenKind;
    116. 

  116.     function Func53: TtkTokenKind;
    117. 

  117.     function Func54: TtkTokenKind;
    118. 

  118.     function Func55: TtkTokenKind;
    119. 

  119.     function Func56: TtkTokenKind;
    120. 

  120.     function Func57: TtkTokenKind;
    121. 

  121.     function Func58: TtkTokenKind;    
    122. 

  122.     function Func59: TtkTokenKind;
    123. 

  123.     function Func60: TtkTokenKind;
    124. 

  124.     function Func61: TtkTokenKind;
    125. 

  125.     function Func62: TtkTokenKind;
    126. 

  126.     function Func63: TtkTokenKind;
    127. 

  127.     function Func64: TtkTokenKind;
    128. 

  128.     function Func65: TtkTokenKind;
    129. 

  129.     function Func66: TtkTokenKind;
    130. 

  130.     function Func67: TtkTokenKind;
    131. 

  131.     function Func69: TtkTokenKind;
    132. 

  132.     function Func70: TtkTokenKind;
    133. 

  133.     function Func71: TtkTokenKind;
    134. 

  134.     function Func72: TtkTokenKind;    
    135. 

  135.     function Func74: TtkTokenKind;
    136. 

  136.     function Func76: TtkTokenKind;
    137. 

  137.     function Func78: TtkTokenKind;
    138. 

  138.     function Func79: TtkTokenKind;
    139. 

  139.     function Func80: TtkTokenKind;
    140. 

  140.     function Func81: TtkTokenKind;
    141. 

  141.     function Func82: TtkTokenKind;
    142. 

  142.     function Func83: TtkTokenKind;
    143. 

  143.     function Func84: TtkTokenKind;
    144. 

  144.     function Func85: TtkTokenKind;
    145. 

  145.     function Func86: TtkTokenKind;
    146. 

  146.     function Func87: TtkTokenKind;
    147. 

  147.     function Func88: TtkTokenKind;
    148. 

  148.     function Func89: TtkTokenKind;
    149. 

  149.     function Func90: TtkTokenKind;
    150. 

  150.     function Func91: TtkTokenKind;
    151. 

  151.     function Func92: TtkTokenKind;
    152. 

  152.     function Func93: TtkTokenKind;
    153. 

  153.     function Func94: TtkTokenKind;
    154. 

  154.     function Func95: TtkTokenKind;
    155. 

  155.     function Func96: TtkTokenKind;
    156. 

  156.     function Func97: TtkTokenKind;
    157. 

  157.     function Func98: TtkTokenKind;
    158. 

  158.     function Func99: TtkTokenKind;    
    159. 

  159.     function Func100: TtkTokenKind;
    160. 

  160.     function Func101: TtkTokenKind;
    161. 

  161.     function Func102: TtkTokenKind;
    162. 

  162.     function Func103: TtkTokenKind;
    163. 

  163.     function Func105: TtkTokenKind;
    164. 

  164.     function Func106: TtkTokenKind;
    165. 

  165.     function Func107: TtkTokenKind;
    166. 

  166.     function Func108: TtkTokenKind;
    167. 

  167.     function Func109: TtkTokenKind;
    168. 

  168.     function Func110: TtkTokenKind;
    169. 

  169.     function Func111: TtkTokenKind;
    170. 

  170.     function Func112: TtkTokenKind;
    171. 

  171.     function Func113: TtkTokenKind;    
    172. 

  172.     function Func114: TtkTokenKind;
    173. 

  173.     function Func115: TtkTokenKind;
    174. 

  174.     function Func116: TtkTokenKind;
    175. 

  175.     function Func117: TtkTokenKind;
    176. 

  176.     function Func118: TtkTokenKind;
    177. 

  177.     function Func119: TtkTokenKind;
    178. 

  178.     function Func120: TtkTokenKind;
    179. 

  179.     function Func121: TtkTokenKind;
    180. 

  180.     function Func122: TtkTokenKind;
    181. 

  181.     function Func123: TtkTokenKind;
    182. 

  182.     function Func124: TtkTokenKind;
    183. 

  183.     function Func125: TtkTokenKind;
    184. 

  184.     function Func126: TtkTokenKind;
    185. 

  185.     function Func127: TtkTokenKind;
    186. 

  186.     function Func128: TtkTokenKind;
    187. 

  187.     function Func129: TtkTokenKind;
    188. 

  188.     function Func130: TtkTokenKind;
    189. 

  189.     function Func131: TtkTokenKind;
    190. 

  190.     function Func132: TtkTokenKind;
    191. 

  191.     function Func134: TtkTokenKind;
    192. 

  192.     function Func136: TtkTokenKind;
    193. 

  193.     function Func137: TtkTokenKind;
    194. 

  194.     function Func138: TtkTokenKind;
    195. 

  195.     function Func139: TtkTokenKind;
    196. 

  196.     function Func140: TtkTokenKind;
    197. 

  197.     function Func141: TtkTokenKind;
    198. 

  198.     function Func142: TtkTokenKind;
    199. 

  199.     function Func144: TtkTokenKind;
    200. 

  200.     function Func146: TtkTokenKind;
    201. 

  201.     function Func148: TtkTokenKind;
    202. 

  202.     function Func149: TtkTokenKind;
    203. 

  203.     function Func150: TtkTokenKind;
    204. 

  204.     function Func151: TtkTokenKind;
    205. 

  205.     function Func152: TtkTokenKind;
    206. 

  206.     function Func153: TtkTokenKind;
    207. 

  207.     function Func154: TtkTokenKind;
    208. 

  208.     function Func156: TtkTokenKind;
    209. 

  209.     function Func158: TtkTokenKind;
    210. 

  210.     function Func159: TtkTokenKind;
    211. 

  211.     function Func160: TtkTokenKind;
    212. 

  212.     function Func164: TtkTokenKind;
    213. 

  213.     function Func166: TtkTokenKind;
    214. 

  214.     function Func167: TtkTokenKind;
    215. 

  215.     function Func169: TtkTokenKind;
    216. 

  216.     function Func171: TtkTokenKind;
    217. 

  217.     function Func172: TtkTokenKind;
    218. 

  218.     function Func173: TtkTokenKind;
    219. 

  219.     function Func174: TtkTokenKind;
    220. 

  220.     function Func175: TtkTokenKind;
    221. 

  221.     function Func177: TtkTokenKind;
    222. 

  222.     function Func178: TtkTokenKind;
    223. 

  223.     function Func179: TtkTokenKind;
    224. 

  224.     function Func182: TtkTokenKind;
    225. 

  225.     function Func186: TtkTokenKind;
    226. 

  226.     function Func187: TtkTokenKind;
    227. 

  227.     function Func190: TtkTokenKind;
    228. 

  228.     function Func191: TtkTokenKind;
    229. 

  229.     function Func194: TtkTokenKind;
    230. 

  230.     function Func195: TtkTokenKind;
    231. 

  231.     function Func198: TtkTokenKind;
    232. 

  232.     function Func199: TtkTokenKind;
    233. 

  233.     function Func200: TtkTokenKind;
    234. 

  234.     function Func205: TtkTokenKind;
    235. 

  235.     function Func210: TtkTokenKind;
    236. 

  236.     function Func213: TtkTokenKind;
    237. 

  237.     function Func216: TtkTokenKind;
    238. 

  238.     function Func220: TtkTokenKind;
    239. 

  239.     function Func222: TtkTokenKind;
    240. 

  240.     function Func224: TtkTokenKind;
    241. 

  241.     function Func232: TtkTokenKind;
    242. 

  242.     function Func242: TtkTokenKind;
    243. 

  243.     function Func250: TtkTokenKind;
    244. 

  244.     function Func253: TtkTokenKind;
    245. 

  245.     function Func275: TtkTokenKind;
    246. 

  246.     procedure SymbolProc;
    247. 

  247.     procedure ColonProc;
    248. 

  248.     procedure SelectorProc;
    249. 

  249.     procedure PercentProc;
    250. 

  250.     procedure CurlyOpenProc;
    251. 

  251.     procedure CurlyCloseProc;
    252. 

  252.     procedure CRProc;
    253. 

  253.     procedure CStyleCommentProc;
    254. 

  254.     procedure DashProc;
    255. 

  255.     procedure IdentProc;
    256. 

  256.     procedure HashProc;
    257. 

  257.     procedure IntegerProc;
    258. 

  258.     procedure LFProc;
    259. 

  259.     procedure NullProc;
    260. 

  260.     procedure NumberProc;
    261. 

  261.     procedure RoundOpenProc;
    262. 

  262.     procedure SlashProc;
    263. 

  263.     procedure SpaceProc;
    264. 

  264.     procedure StringProc;
    265. 

  265.     procedure UnknownProc;
    266. 

  266.     function AltFunc: TtkTokenKind;
    267. 

  267.     procedure InitIdent;
    268. 

  268.     function IdentKind(MayBe: PChar): TtkTokenKind;
    269. 

  269.     procedure MakeMethodTables;
    270. 

  270.   protected
    271. 

  271.     function GetIdentChars: TSynIdentChars; override;
    272. 

  272.     function GetSampleSource: String; override;
    273. 

  273.   public
    274. 

  274.     class function GetLanguageName: string; override;
    275. 

  275.   public
    276. 

  276.     constructor Create(AOwner: TComponent); override;
    277. 

  277.     function GetDefaultAttribute(Index: integer): TSynHighlighterAttributes;
    278. 

  278.       override;
    279. 

  279.     function GetEol: Boolean; override;
    280. 

  280.     function GetRange: Pointer; override;
    281. 

  281.     function GetTokenID: TtkTokenKind;
    282. 

  282.     procedure SetLine(const NewValue: String; LineNumber: Integer); override;
    283. 

  283.     function GetToken: string; override;
    284. 

  284.     procedure GetTokenEx(out TokenStart: PChar; out TokenLength: integer); override;
    285. 

  285.     function GetTokenAttribute: TSynHighlighterAttributes; override;
    286. 

  286.     function GetTokenKind: integer; override;
    287. 

  287.     function GetTokenPos: Integer; override;
    288. 

  288.     procedure Next; override;
    289. 

  289.     procedure SetRange(Value: Pointer); override;
    290. 

  290.     procedure ReSetRange; override;
    291. 

  291.     property IdentChars;
    292. 

  292. 

  293.     function KeyHash2(ToHash: PChar): Integer;
    294. 

  294.   published
    295. 

  295.     property CommentAttri: TSynHighlighterAttributes read fCommentAttri
    296. 

  296.       write fCommentAttri;
    297. 

  297.     property IdentifierAttri: TSynHighlighterAttributes read fIdentifierAttri
    298. 

  298.       write fIdentifierAttri;
    299. 

  299.     property KeyAttri: TSynHighlighterAttributes read fKeyAttri write fKeyAttri;
    300. 

  300.     property NumberAttri: TSynHighlighterAttributes read fNumberAttri
    301. 

  301.       write fNumberAttri;
    302. 

  302.     property SpaceAttri: TSynHighlighterAttributes read fSpaceAttri
    303. 

  303.       write fSpaceAttri;
    304. 

  304.     property StringAttri: TSynHighlighterAttributes read fStringAttri
    305. 

  305.       write fStringAttri;
    306. 

  306.     property SymbolAttri: TSynHighlighterAttributes read fSymbolAttri
    307. 

  307.       write fSymbolAttri;
    308. 

  308.     property MeasurementUnitAttri: TSynHighlighterAttributes read fMeasurementUnitAttri
    309. 

  309.       write fMeasurementUnitAttri;
    310. 

  310.     property SelectorAttri: TSynHighlighterAttributes read fSelectorAttri
    311. 

  311.       write fSelectorAttri;
    312. 

  312.   end;
    313. 

  313. 

  314. implementation
    315. 

  315. 

  316. uses
    317. 

  317.   SynEditStrConst;
    318. 

  318. 

  319. var
    320. 

  320.   Identifiers: array[#0..#255] of ByteBool;
    321. 

  321.   mHashTable : array[#0..#255] of Integer;
    322. 

  322. 

  323. procedure MakeIdentTable;
    324. 

  324. var
    325. 

  325.   I, J: Char;
    326. 

  326. begin
    327. 

  327.   for I := #0 to #255 do begin
    328. 

  328.     case I of
    329. 

  329.       'a'..'z', 'A'..'Z', '-', '_', '0'..'9','@': Identifiers[I] := True;
    330. 

  330.     else
    331. 

  331.       Identifiers[I] := False;
    332. 

  332.     end;
    333. 

  333.     J := UpCase(I);
    334. 

  334.     if I in ['a'..'z', 'A'..'Z', '-', '_','@'] then
    335. 

  335.       mHashTable[I] := Ord(J) - 64
    336. 

  336.     else
    337. 

  337.       mHashTable[I] := 0;
    338. 

  338.   end;
    339. 

  339. end;
    340. 

  340. 

  341. procedure TSynCssSyn.InitIdent;
    342. 

  342. var
    343. 

  343.   I: Integer;
    344. 

  344.   pF: PIdentFuncTableFunc;
    345. 

  345. begin
    346. 

  346.   pF := PIdentFuncTableFunc(@FIdentFuncTable);
    347. 

  347.   for I := Low(FIdentFuncTable) to High(FIdentFuncTable) do begin
    348. 

  348.     pF^ :=  @AltFunc;
    349. 

  349.     Inc(pF);
    350. 

  350.   end;
    351. 

  351.   FIdentFuncTable[16] := @Func16;
    352. 

  352.   FIdentFuncTable[18] := @Func18;
    353. 

  353.   FIdentFuncTable[19] := @Func19;
    354. 

  354.   FIdentFuncTable[23] := @Func23;
    355. 

  355.   FIdentFuncTable[24] := @Func24;
    356. 

  356.   FIdentFuncTable[26] := @Func26;
    357. 

  357.   FIdentFuncTable[29] := @Func29;
    358. 

  358.   FIdentFuncTable[30] := @Func30;
    359. 

  359.   FIdentFuncTable[32] := @Func32;
    360. 

  360.   FIdentFuncTable[34] := @Func34;
    361. 

  361.   FIdentFuncTable[36] := @Func36;
    362. 

  362.   FIdentFuncTable[39] := @Func39;
    363. 

  363.   FIdentFuncTable[40] := @Func40;
    364. 

  364.   FIdentFuncTable[41] := @Func41;
    365. 

  365.   FIdentFuncTable[43] := @Func43;
    366. 

  366.   FIdentFuncTable[45] := @Func45;
    367. 

  367.   FIdentFuncTable[47] := @Func47;
    368. 

  368.   FIdentFuncTable[51] := @Func51;
    369. 

  369.   FIdentFuncTable[52] := @Func52;
    370. 

  370.   FIdentFuncTable[53] := @Func53;
    371. 

  371.   FIdentFuncTable[54] := @Func54;
    372. 

  372.   FIdentFuncTable[55] := @Func55;
    373. 

  373.   FIdentFuncTable[56] := @Func56;
    374. 

  374.   FIdentFuncTable[57] := @Func57;
    375. 

  375.   FIdentFuncTable[58] := @Func58;
    376. 

  376.   FIdentFuncTable[59] := @Func59;
    377. 

  377.   FIdentFuncTable[60] := @Func60;
    378. 

  378.   FIdentFuncTable[61] := @Func61;
    379. 

  379.   FIdentFuncTable[62] := @Func62;
    380. 

  380.   FIdentFuncTable[63] := @Func63;
    381. 

  381.   FIdentFuncTable[64] := @Func64;
    382. 

  382.   FIdentFuncTable[65] := @Func65;
    383. 

  383.   FIdentFuncTable[66] := @Func66;
    384. 

  384.   FIdentFuncTable[67] := @Func67;
    385. 

  385.   FIdentFuncTable[69] := @Func69;
    386. 

  386.   FIdentFuncTable[70] := @Func70;
    387. 

  387.   FIdentFuncTable[71] := @Func71;
    388. 

  388.   FIdentFuncTable[72] := @Func72;
    389. 

  389.   FIdentFuncTable[74] := @Func74;
    390. 

  390.   FIdentFuncTable[76] := @Func76;
    391. 

  391.   FIdentFuncTable[78] := @Func78;
    392. 

  392.   FIdentFuncTable[79] := @Func79;
    393. 

  393.   FIdentFuncTable[80] := @Func80;
    394. 

  394.   FIdentFuncTable[81] := @Func81;
    395. 

  395.   FIdentFuncTable[82] := @Func82;
    396. 

  396.   FIdentFuncTable[83] := @Func83;
    397. 

  397.   FIdentFuncTable[84] := @Func84;
    398. 

  398.   FIdentFuncTable[85] := @Func85;
    399. 

  399.   FIdentFuncTable[86] := @Func86;
    400. 

  400.   FIdentFuncTable[87] := @Func87;
    401. 

  401.   FIdentFuncTable[88] := @Func88;
    402. 

  402.   FIdentFuncTable[89] := @Func89;
    403. 

  403.   FIdentFuncTable[90] := @Func90;
    404. 

  404.   FIdentFuncTable[91] := @Func91;
    405. 

  405.   FIdentFuncTable[92] := @Func92;
    406. 

  406.   FIdentFuncTable[93] := @Func93;
    407. 

  407.   FIdentFuncTable[94] := @Func94;
    408. 

  408.   FIdentFuncTable[95] := @Func95;
    409. 

  409.   FIdentFuncTable[96] := @Func96;
    410. 

  410.   FIdentFuncTable[97] := @Func97;
    411. 

  411.   FIdentFuncTable[98] := @Func98;
    412. 

  412.   FIdentFuncTable[99] := @Func99;
    413. 

  413.   FIdentFuncTable[100] := @Func100;
    414. 

  414.   FIdentFuncTable[101] := @Func101;
    415. 

  415.   FIdentFuncTable[102] := @Func102;
    416. 

  416.   FIdentFuncTable[103] := @Func103;
    417. 

  417.   FIdentFuncTable[105] := @Func105;
    418. 

  418.   FIdentFuncTable[106] := @Func106;
    419. 

  419.   FIdentFuncTable[107] := @Func107;
    420. 

  420.   FIdentFuncTable[108] := @Func108;
    421. 

  421.   FIdentFuncTable[109] := @Func109;
    422. 

  422.   FIdentFuncTable[110] := @Func110;
    423. 

  423.   FIdentFuncTable[111] := @Func111;
    424. 

  424.   FIdentFuncTable[112] := @Func112;
    425. 

  425.   FIdentFuncTable[113] := @Func113;
    426. 

  426.   FIdentFuncTable[114] := @Func114;
    427. 

  427.   FIdentFuncTable[115] := @Func115;
    428. 

  428.   FIdentFuncTable[116] := @Func116;
    429. 

  429.   FIdentFuncTable[117] := @Func117;
    430. 

  430.   FIdentFuncTable[118] := @Func118;
    431. 

  431.   FIdentFuncTable[119] := @Func119;
    432. 

  432.   FIdentFuncTable[120] := @Func120;
    433. 

  433.   FIdentFuncTable[121] := @Func121;
    434. 

  434.   FIdentFuncTable[122] := @Func122;
    435. 

  435.   FIdentFuncTable[123] := @Func123;
    436. 

  436.   FIdentFuncTable[124] := @Func124;
    437. 

  437.   FIdentFuncTable[125] := @Func125;
    438. 

  438.   FIdentFuncTable[126] := @Func126;
    439. 

  439.   FIdentFuncTable[127] := @Func127;
    440. 

  440.   FIdentFuncTable[128] := @Func128;
    441. 

  441.   FIdentFuncTable[129] := @Func129;
    442. 

  442.   FIdentFuncTable[130] := @Func130;
    443. 

  443.   FIdentFuncTable[131] := @Func131;
    444. 

  444.   FIdentFuncTable[132] := @Func132;
    445. 

  445.   FIdentFuncTable[134] := @Func134;
    446. 

  446.   FIdentFuncTable[136] := @Func136;
    447. 

  447.   FIdentFuncTable[137] := @Func137;
    448. 

  448.   FIdentFuncTable[138] := @Func138;
    449. 

  449.   FIdentFuncTable[139] := @Func139;
    450. 

  450.   FIdentFuncTable[140] := @Func140;
    451. 

  451.   FIdentFuncTable[141] := @Func141;
    452. 

  452.   FIdentFuncTable[142] := @Func142;
    453. 

  453.   FIdentFuncTable[144] := @Func144;
    454. 

  454.   FIdentFuncTable[146] := @Func146;
    455. 

  455.   FIdentFuncTable[148] := @Func148;
    456. 

  456.   FIdentFuncTable[149] := @Func149;
    457. 

  457.   FIdentFuncTable[150] := @Func150;
    458. 

  458.   FIdentFuncTable[151] := @Func151;
    459. 

  459.   FIdentFuncTable[152] := @Func152;
    460. 

  460.   FIdentFuncTable[153] := @Func153;
    461. 

  461.   FIdentFuncTable[154] := @Func154;
    462. 

  462.   FIdentFuncTable[156] := @Func156;
    463. 

  463.   FIdentFuncTable[158] := @Func158;
    464. 

  464.   FIdentFuncTable[159] := @Func159;
    465. 

  465.   FIdentFuncTable[160] := @Func160;
    466. 

  466.   FIdentFuncTable[164] := @Func164;
    467. 

  467.   FIdentFuncTable[166] := @Func166;
    468. 

  468.   FIdentFuncTable[167] := @Func167;
    469. 

  469.   FIdentFuncTable[169] := @Func169;
    470. 

  470.   FIdentFuncTable[171] := @Func171;
    471. 

  471.   FIdentFuncTable[172] := @Func172;
    472. 

  472.   FIdentFuncTable[173] := @Func173;
    473. 

  473.   FIdentFuncTable[174] := @Func174;
    474. 

  474.   FIdentFuncTable[175] := @Func175;
    475. 

  475.   FIdentFuncTable[177] := @Func177;
    476. 

  476.   FIdentFuncTable[178] := @Func178;
    477. 

  477.   FIdentFuncTable[179] := @Func179;
    478. 

  478.   FIdentFuncTable[182] := @Func182;
    479. 

  479.   FIdentFuncTable[186] := @Func186;
    480. 

  480.   FIdentFuncTable[187] := @Func187;
    481. 

  481.   FIdentFuncTable[190] := @Func190;
    482. 

  482.   FIdentFuncTable[191] := @Func191;
    483. 

  483.   FIdentFuncTable[194] := @Func194;
    484. 

  484.   FIdentFuncTable[195] := @Func195;
    485. 

  485.   FIdentFuncTable[198] := @Func198;
    486. 

  486.   FIdentFuncTable[199] := @Func199;
    487. 

  487.   FIdentFuncTable[200] := @Func200;
    488. 

  488.   FIdentFuncTable[205] := @Func205;
    489. 

  489.   FIdentFuncTable[210] := @Func210;
    490. 

  490.   FIdentFuncTable[213] := @Func213;
    491. 

  491.   FIdentFuncTable[216] := @Func216;
    492. 

  492.   FIdentFuncTable[220] := @Func220;
    493. 

  493.   FIdentFuncTable[222] := @Func222;
    494. 

  494.   FIdentFuncTable[224] := @Func224;
    495. 

  495.   FIdentFuncTable[232] := @Func232;
    496. 

  496.   FIdentFuncTable[242] := @Func242;
    497. 

  497.   FIdentFuncTable[250] := @Func250;
    498. 

  498.   FIdentFuncTable[253] := @Func253;
    499. 

  499.   FIdentFuncTable[275] := @Func275;
    500. 

  500. end;
    501. 

  501. 

  502. function TSynCssSyn.KeyHash(ToHash: PChar): Integer;
    503. 

  503. begin
    504. 

  504.   Result := 0;
    505. 

  505.   while ToHash^ in ['a'..'z', 'A'..'Z', '0'..'9', '-', '_','@'] do begin
    506. 

  506.     Inc(Result, mHashTable[ToHash^]);
    507. 

  507.     Inc(ToHash);
    508. 

  508.   end;
    509. 

  509.   FStringLen := ToHash - FToIdent;
    510. 

  510. end;
    511. 

  511. 

  512. function TSynCssSyn.KeyComp(const aKey: String): Boolean;
    513. 

  513. var
    514. 

  514.   iI  : Integer;
    515. 

  515.   Temp: PChar;
    516. 

  516. begin
    517. 

  517.   Temp := FToIdent;
    518. 

  518.   if Length(aKey) = FStringLen then begin
    519. 

  519.     Result := True;
    520. 

  520.     for iI := 1 to fStringLen do begin
    521. 

  521.       if mHashTable[Temp^] <> mHashTable[aKey[iI]] then begin
    522. 

  522.         Result := False;
    523. 

  523.         Break;
    524. 

  524.       end;
    525. 

  525.       Inc(Temp);
    526. 

  526.     end;
    527. 

  527.   end else
    528. 

  528.     Result := False;
    529. 

  529. end;
    530. 

  530. 

  531. function TSynCssSyn.Func16: TtkTokenKind;
    532. 

  532. begin
    533. 

  533.   if KeyComp('cm') then
    534. 

  534.     Result := tkMeasurementUnit
    535. 

  535.   else
    536. 

  536.   if KeyComp('deg') then
    537. 

  537.     Result := tkKey
    538. 

  538.   else
    539. 

  539.     Result := tkIdentifier;
    540. 

  540. end;
    541. 

  541. 

  542. function TSynCssSyn.Func18: TtkTokenKind;
    543. 

  543. begin
    544. 

  544.   if KeyComp('em') then
    545. 

  545.     Result := tkMeasurementUnit
    546. 

  546.   else
    547. 

  547.     Result := tkIdentifier;
    548. 

  548. end;
    549. 

  549. 

  550. function TSynCssSyn.Func19: TtkTokenKind;
    551. 

  551. begin
    552. 

  552.   if KeyComp('pc') then
    553. 

  553.     Result := tkMeasurementUnit
    554. 

  554.   else if KeyComp('s') then
    555. 

  555.     Result := tkKey
    556. 

  556.   else
    557. 

  557.     Result := tkIdentifier;
    558. 

  558. end;
    559. 

  559. 

  560. function TSynCssSyn.Func23: TtkTokenKind;
    561. 

  561. begin
    562. 

  562.   if KeyComp('in') then
    563. 

  563.     Result := tkMeasurementUnit
    564. 

  564.   else
    565. 

  565.   if  KeyComp('rad') then
    566. 

  566.     Result := tkKey
    567. 

  567.   else
    568. 

  568.     Result := tkIdentifier;
    569. 

  569. end;
    570. 

  570. 

  571. function TSynCssSyn.Func24: TtkTokenKind;
    572. 

  572. begin
    573. 

  573.   if KeyComp('b-box') then
    574. 

  574.     Result := tkKey
    575. 

  575.   else
    576. 

  576.     Result := tkIdentifier;
    577. 

  577. end;
    578. 

  578. 

  579. function TSynCssSyn.Func26: TtkTokenKind;
    580. 

  580. begin
    581. 

  581.   if KeyComp('mm') then
    582. 

  582.     Result := tkMeasurementUnit
    583. 

  583.   else
    584. 

  584.     Result := tkIdentifier;
    585. 

  585. end;
    586. 

  586. 

  587. function TSynCssSyn.Func29: TtkTokenKind;
    588. 

  588. begin
    589. 

  589.   if KeyComp('page') or KeyComp('cue') then
    590. 

  590.     Result := tkKey
    591. 

  591.   else if KeyComp('ex') then
    592. 

  592.     Result := tkMeasurementUnit
    593. 

  593.   else
    594. 

  594.     Result := tkIdentifier;
    595. 

  595. end;
    596. 

  596. 

  597. function TSynCssSyn.Func30: TtkTokenKind;
    598. 

  598. begin
    599. 

  599.   if KeyComp('grad') then
    600. 

  600.     Result := tkKey
    601. 

  601.   else
    602. 

  602.     Result := tkIdentifier;
    603. 

  603. end;
    604. 

  604. 

  605. function TSynCssSyn.Func32: TtkTokenKind;
    606. 

  606. begin
    607. 

  607.   if KeyComp('ms') or KeyComp('@media') then
    608. 

  608.     Result := tkKey
    609. 

  609.   else
    610. 

  610.     Result := tkIdentifier;
    611. 

  611. end;
    612. 

  612. 

  613. function TSynCssSyn.Func34: TtkTokenKind;
    614. 

  614. begin
    615. 

  615.   if KeyComp('Hz') then
    616. 

  616.     Result := tkKey
    617. 

  617.   else
    618. 

  618.     Result := tkIdentifier;
    619. 

  619. end;
    620. 

  620. 

  621. function TSynCssSyn.Func36: TtkTokenKind;
    622. 

  622. begin
    623. 

  623.   if KeyComp('pt') then
    624. 

  624.     Result := tkMeasurementUnit
    625. 

  625.   else
    626. 

  626.     Result := tkIdentifier;
    627. 

  627. end;
    628. 

  628. 

  629. function TSynCssSyn.Func39: TtkTokenKind;
    630. 

  630. begin
    631. 

  631.   if KeyComp('clear') then
    632. 

  632.     Result := tkKey
    633. 

  633.   else
    634. 

  634.     Result := tkIdentifier;
    635. 

  635. end;
    636. 

  636. 

  637. function TSynCssSyn.Func40: TtkTokenKind;
    638. 

  638. begin
    639. 

  639.   if KeyComp('px') then
    640. 

  640.     Result := tkMeasurementUnit
    641. 

  641.   else
    642. 

  642.   if KeyComp('clip') or KeyComp('src') then
    643. 

  643.     Result := tkKey
    644. 

  644.   else
    645. 

  645.     Result := tkIdentifier;
    646. 

  646. end;
    647. 

  647. 

  648. function TSynCssSyn.Func41: TtkTokenKind;
    649. 

  649. begin
    650. 

  650.   if KeyComp('icon') then
    651. 

  651.     Result := tkKey
    652. 

  652.   else
    653. 

  653.     Result := tkIdentifier;
    654. 

  654. end;
    655. 

  655. 

  656. function TSynCssSyn.Func43: TtkTokenKind;
    657. 

  657. begin
    658. 

  658.   if KeyComp('left') then
    659. 

  659.     Result := tkKey
    660. 

  660.   else
    661. 

  661.     Result := tkIdentifier;
    662. 

  662. end;
    663. 

  663. 

  664. function TSynCssSyn.Func45: TtkTokenKind;
    665. 

  665. begin
    666. 

  666.   if KeyComp('ime-mode') or KeyComp('kHz') then
    667. 

  667.     Result := tkKey
    668. 

  668.   else
    669. 

  669.     Result := tkIdentifier;
    670. 

  670. end;
    671. 

  671. 

  672. function TSynCssSyn.Func47: TtkTokenKind;
    673. 

  673. begin
    674. 

  674.   if KeyComp('flex') then
    675. 

  675.     Result := tkKey
    676. 

  676.   else
    677. 

  677.     Result := tkIdentifier;
    678. 

  678. end;
    679. 

  679. 

  680. function TSynCssSyn.Func51: TtkTokenKind;
    681. 

  681. begin
    682. 

  682.   if KeyComp('top') or KeyComp('panose-1') or KeyComp('@font-face') then
    683. 

  683.     Result := tkKey
    684. 

  684.   else
    685. 

  685.     Result := tkIdentifier;
    686. 

  686. end;
    687. 

  687. 

  688. function TSynCssSyn.Func52: TtkTokenKind;
    689. 

  689. begin
    690. 

  690.   if KeyComp('speak') then
    691. 

  691.     Result := tkKey
    692. 

  692.   else
    693. 

  693.     Result := tkIdentifier;
    694. 

  694. end;
    695. 

  695. 

  696. function TSynCssSyn.Func53: TtkTokenKind;
    697. 

  697. begin
    698. 

  698.   if KeyComp('box-pack') then
    699. 

  699.     Result := tkKey
    700. 

  700.   else
    701. 

  701.     Result := tkIdentifier;
    702. 

  702. end;
    703. 

  703. 

  704. function TSynCssSyn.Func54: TtkTokenKind;
    705. 

  705. begin
    706. 

  706.   if KeyComp('float') then
    707. 

  707.     Result := tkKey
    708. 

  708.   else
    709. 

  709.     Result := tkIdentifier;
    710. 

  710. end;
    711. 

  711. 

  712. function TSynCssSyn.Func55: TtkTokenKind;
    713. 

  713. begin
    714. 

  714.   if KeyComp('font') or KeyComp('padding') or KeyComp('nav-up') then
    715. 

  715.     Result := tkKey
    716. 

  716.   else
    717. 

  717.     Result := tkIdentifier;
    718. 

  718. end;
    719. 

  719. 

  720. function TSynCssSyn.Func56: TtkTokenKind;
    721. 

  721. begin
    722. 

  722.   if KeyComp('pitch') then
    723. 

  723.     Result := tkKey
    724. 

  724.   else
    725. 

  725.     Result := tkIdentifier;
    726. 

  726. end;
    727. 

  727. 

  728. function TSynCssSyn.Func57: TtkTokenKind;
    729. 

  729. begin
    730. 

  730.   if KeyComp('height') or KeyComp('run-in') then
    731. 

  731.     Result := tkKey
    732. 

  732.   else
    733. 

  733.     Result := tkIdentifier;
    734. 

  734. end;
    735. 

  735. 

  736. function TSynCssSyn.Func58: TtkTokenKind;
    737. 

  737. begin
    738. 

  738.   if KeyComp('line-break') or KeyComp('cap-height') then
    739. 

  739.     Result := tkKey
    740. 

  740.   else
    741. 

  741.     Result := tkIdentifier;
    742. 

  742. end;
    743. 

  743. 

  744. function TSynCssSyn.Func59: TtkTokenKind;
    745. 

  745. begin
    746. 

  746.   if KeyComp('size') then
    747. 

  747.     Result := tkKey
    748. 

  748.   else
    749. 

  749.     Result := tkIdentifier;
    750. 

  750. end;
    751. 

  751. 

  752. function TSynCssSyn.Func60: TtkTokenKind;
    753. 

  753. begin
    754. 

  754.   if KeyComp('cue-after') or KeyComp('order') then
    755. 

  755.     Result := tkKey
    756. 

  756.   else
    757. 

  757.     Result := tkIdentifier;
    758. 

  758. end;
    759. 

  759. 

  760. function TSynCssSyn.Func61: TtkTokenKind;
    761. 

  761. begin
    762. 

  762.   if KeyComp('cue-before') or KeyComp('nav-left') then
    763. 

  763.     Result := tkKey
    764. 

  764.   else
    765. 

  765.     Result := tkIdentifier;
    766. 

  766. end;
    767. 

  767. 

  768. function TSynCssSyn.Func62: TtkTokenKind;
    769. 

  769. begin
    770. 

  770.   if KeyComp('margin') or KeyComp('pause') or KeyComp('right') or
    771. 

  771.     KeyComp('marks') or KeyComp('border') or KeyComp('x-height') or
    772. 

  772.     KeyComp('ascent') then
    773. 

  773.     Result := tkKey
    774. 

  774.   else
    775. 

  775.     Result := tkIdentifier;
    776. 

  776. end;
    777. 

  777. 

  778. function TSynCssSyn.Func63: TtkTokenKind;
    779. 

  779. begin
    780. 

  780.   if KeyComp('color') or KeyComp('z-index') or KeyComp('tab-size') then
    781. 

  781.     Result := tkKey
    782. 

  782.   else
    783. 

  783.     Result := tkIdentifier;
    784. 

  784. end;
    785. 

  785. 

  786. function TSynCssSyn.Func64: TtkTokenKind;
    787. 

  787. begin
    788. 

  788.   if KeyComp('width') then
    789. 

  789.     Result := tkKey
    790. 

  790.   else
    791. 

  791.     Result := tkIdentifier;
    792. 

  792. end;
    793. 

  793. 

  794. function TSynCssSyn.Func65: TtkTokenKind;
    795. 

  795. begin
    796. 

  796.   if KeyComp('stemh') or KeyComp('box-align')  then
    797. 

  797.     Result := tkKey
    798. 

  798.   else
    799. 

  799.     Result := tkIdentifier;
    800. 

  800. end;
    801. 

  801. 

  802. function TSynCssSyn.Func66: TtkTokenKind;
    803. 

  803. begin
    804. 

  804.   if KeyComp('align-self') then
    805. 

  805.     Result := tkKey
    806. 

  806.   else
    807. 

  807.     Result := tkIdentifier;
    808. 

  808. end;
    809. 

  809. 

  810. function TSynCssSyn.Func67: TtkTokenKind;
    811. 

  811. begin
    812. 

  812.   if KeyComp('slope') or KeyComp('baseline') then
    813. 

  813.     Result := tkKey
    814. 

  814.   else
    815. 

  815.     Result := tkIdentifier;
    816. 

  816. end;
    817. 

  817. 

  818. function TSynCssSyn.Func69: TtkTokenKind;
    819. 

  819. begin
    820. 

  820.   if KeyComp('zoom') or KeyComp('box-flex') then
    821. 

  821.     Result := tkKey
    822. 

  822.   else
    823. 

  823.     Result := tkIdentifier;
    824. 

  824. end;
    825. 

  825. 

  826. function TSynCssSyn.Func70: TtkTokenKind;
    827. 

  827. begin
    828. 

  828.   if KeyComp('filter') or KeyComp('descent') then
    829. 

  829.     Result := tkKey
    830. 

  830.   else
    831. 

  831.     Result := tkIdentifier;
    832. 

  832. end;
    833. 

  833. 

  834. function TSynCssSyn.Func71: TtkTokenKind;
    835. 

  835. begin
    836. 

  836.   if KeyComp('target') or KeyComp('object-fit') then
    837. 

  837.     Result := tkKey
    838. 

  838.   else
    839. 

  839.     Result := tkIdentifier;
    840. 

  840. end;
    841. 

  841. 

  842. function TSynCssSyn.Func72: TtkTokenKind;
    843. 

  843. begin
    844. 

  844.   if KeyComp('top-line') then
    845. 

  845.     Result := tkKey
    846. 

  846.   else
    847. 

  847.     Result := tkIdentifier;
    848. 

  848. end;
    849. 

  849. 

  850. function TSynCssSyn.Func74: TtkTokenKind;
    851. 

  851. begin
    852. 

  852.   if KeyComp('speak-header') or KeyComp('min-height') or KeyComp('nav-down')
    853. 

  853.     or KeyComp('nav-index') or KeyComp('@charset') then
    854. 

  854.     Result := tkKey
    855. 

  855.   else
    856. 

  856.     Result := tkIdentifier;
    857. 

  857. end;
    858. 

  858. 

  859. function TSynCssSyn.Func76: TtkTokenKind;
    860. 

  860. begin
    861. 

  861.   if KeyComp('max-height') or KeyComp('unicode-bidi') then
    862. 

  862.     Result := tkKey
    863. 

  863.   else
    864. 

  864.     Result := tkIdentifier;
    865. 

  865. end;
    866. 

  866. 

  867. function TSynCssSyn.Func78: TtkTokenKind;
    868. 

  868. begin
    869. 

  869.   if KeyComp('page-break-after') or KeyComp('word-break') or KeyComp('border-image')
    870. 

  870.     or KeyComp('line-height') or KeyComp('flex-basis') then
    871. 

  871.     Result := tkKey
    872. 

  872.   else
    873. 

  873.     Result := tkIdentifier;
    874. 

  874. end;
    875. 

  875. 

  876. function TSynCssSyn.Func79: TtkTokenKind;
    877. 

  877. begin
    878. 

  878.   if KeyComp('padding-left') or KeyComp('page-break-before') or
    879. 

  879.     KeyComp('stemv') then
    880. 

  880.     Result := tkKey
    881. 

  881.   else
    882. 

  882.     Result := tkIdentifier;
    883. 

  883. end;
    884. 

  884. 

  885. function TSynCssSyn.Func80: TtkTokenKind;
    886. 

  886. begin
    887. 

  887.   if KeyComp('behavior') or KeyComp('appearance') or KeyComp('nav-right') then
    888. 

  888.     Result := tkKey
    889. 

  889.   else
    890. 

  890.     Result := tkIdentifier;
    891. 

  891. end;
    892. 

  892. 

  893. function TSynCssSyn.Func81: TtkTokenKind;
    894. 

  894. begin
    895. 

  895.   if KeyComp('speech-rate') or KeyComp('min-width')  or KeyComp('box-lines') then
    896. 

  896.     Result := tkKey
    897. 

  897.   else
    898. 

  898.     Result := tkIdentifier;
    899. 

  899. end;
    900. 

  900. 

  901. function TSynCssSyn.Func82: TtkTokenKind;
    902. 

  902. begin
    903. 

  903.   if KeyComp('pitch-range') or KeyComp('mathline') or KeyComp('resize') then
    904. 

  904.     Result := tkKey
    905. 

  905.   else
    906. 

  906.     Result := tkIdentifier;
    907. 

  907. end;
    908. 

  908. 

  909. function TSynCssSyn.Func83: TtkTokenKind;
    910. 

  910. begin
    911. 

  911.   if KeyComp('max-width') or KeyComp('widths') or KeyComp('column-gap') then
    912. 

  912.     Result := tkKey
    913. 

  913.   else
    914. 

  914.     Result := tkIdentifier;
    915. 

  915. end;
    916. 

  916. 

  917. function TSynCssSyn.Func84: TtkTokenKind;
    918. 

  918. begin
    919. 

  919.   if KeyComp('flex-flow') then
    920. 

  920.     Result := tkKey
    921. 

  921.   else
    922. 

  922.     Result := tkIdentifier;
    923. 

  923. end;
    924. 

  924. 

  925. function TSynCssSyn.Func85: TtkTokenKind;
    926. 

  926. begin
    927. 

  927.   if KeyComp('bottom') or KeyComp('target-name') then
    928. 

  928.     Result := tkKey
    929. 

  929.   else
    930. 

  930.     Result := tkIdentifier;
    931. 

  931. end;
    932. 

  932. 

  933. function TSynCssSyn.Func86: TtkTokenKind;
    934. 

  934. begin
    935. 

  935.   if KeyComp('margin-left') or KeyComp('border-left') or KeyComp('display') or KeyComp('flex-wrap') then
    936. 

  936.     Result := tkKey
    937. 

  937.   else
    938. 

  938.     Result := tkIdentifier;
    939. 

  939. end;
    940. 

  940. 

  941. function TSynCssSyn.Func87: TtkTokenKind;
    942. 

  942. begin
    943. 

  943.   if KeyComp('padding-top') then
    944. 

  944.     Result := tkKey
    945. 

  945.   else
    946. 

  946.     Result := tkIdentifier;
    947. 

  947. end;
    948. 

  948. 

  949. function TSynCssSyn.Func88: TtkTokenKind;
    950. 

  950. begin
    951. 

  951.   if KeyComp('page-break-inside') or KeyComp('volume') then
    952. 

  952.     Result := tkKey
    953. 

  953.   else
    954. 

  954.     Result := tkIdentifier;
    955. 

  955. end;
    956. 

  956. 

  957. function TSynCssSyn.Func89: TtkTokenKind;
    958. 

  958. begin
    959. 

  959.   if KeyComp('opacity') then
    960. 

  960.     Result := tkKey
    961. 

  961.   else
    962. 

  962.     Result := tkIdentifier;
    963. 

  963. end;
    964. 

  964. 

  965. function TSynCssSyn.Func90: TtkTokenKind;
    966. 

  966. begin
    967. 

  967.   if KeyComp('white-space') or KeyComp('ruby-align') or KeyComp('align-items') then
    968. 

  968.     Result := tkKey
    969. 

  969.   else
    970. 

  970.     Result := tkIdentifier;
    971. 

  971. end;
    972. 

  972. 

  973. function TSynCssSyn.Func91: TtkTokenKind;
    974. 

  974. begin
    975. 

  975.   if KeyComp('orphans') or KeyComp('content') or KeyComp('@import') or KeyComp('flex-grow') then
    976. 

  976.     Result := tkKey
    977. 

  977.   else
    978. 

  978.     Result := tkIdentifier;
    979. 

  979. end;
    980. 

  980. 

  981. function TSynCssSyn.Func92: TtkTokenKind;
    982. 

  982. begin
    983. 

  983.   if KeyComp('box-shadow') then
    984. 

  984.     Result := tkKey
    985. 

  985.   else
    986. 

  986.     Result := tkIdentifier;
    987. 

  987. end;
    988. 

  988. 

  989. function TSynCssSyn.Func93: TtkTokenKind;
    990. 

  990. begin
    991. 

  991.   if KeyComp('text-align') or KeyComp('pause-after') or KeyComp('widows') then
    992. 

  992.     Result := tkKey
    993. 

  993.   else
    994. 

  994.     Result := tkIdentifier;
    995. 

  995. end;
    996. 

  996. 

  997. function TSynCssSyn.Func94: TtkTokenKind;
    998. 

  998. begin
    999. 

  999.   if KeyComp('margin-top') or KeyComp('border-top') or KeyComp('pause-before') or
    1000. 

  1000.     KeyComp('cursor') or KeyComp('grid-rows') or KeyComp('target-new') then
    1001. 

  1001.     Result := tkKey
    1002. 

  1002.   else
    1003. 

  1003.     Result := tkIdentifier;
    1004. 

  1004. end;
    1005. 

  1005. 

  1006. function TSynCssSyn.Func95: TtkTokenKind;
    1007. 

  1007. begin
    1008. 

  1008.   if KeyComp('font-size') or KeyComp('richness') then
    1009. 

  1009.     Result := tkKey
    1010. 

  1010.   else
    1011. 

  1011.     Result := tkIdentifier;
    1012. 

  1012. end;
    1013. 

  1013. 

  1014. function TSynCssSyn.Func96: TtkTokenKind;
    1015. 

  1015. begin
    1016. 

  1016.   if KeyComp('background') or KeyComp('caption-side') or KeyComp('counter') or
    1017. 

  1017.     KeyComp('outline') or KeyComp('animation')  then
    1018. 

  1018.     Result := tkKey
    1019. 

  1019.   else
    1020. 

  1020.     Result := tkIdentifier;
    1021. 

  1021. end;
    1022. 

  1022. 

  1023. function TSynCssSyn.Func97: TtkTokenKind;
    1024. 

  1024. begin
    1025. 

  1025.   if KeyComp('quotes') or KeyComp('direction') or KeyComp('unicode-range')
    1026. 

  1026.     or KeyComp('columns') then
    1027. 

  1027.     Result := tkKey
    1028. 

  1028.   else
    1029. 

  1029.     Result := tkIdentifier;
    1030. 

  1030. end;
    1031. 

  1031. 

  1032. function TSynCssSyn.Func98: TtkTokenKind;
    1033. 

  1033. begin
    1034. 

  1034.   if KeyComp('padding-right') or KeyComp('azimuth') or KeyComp('column-fill') then
    1035. 

  1035.     Result := tkKey
    1036. 

  1036.   else
    1037. 

  1037.     Result := tkIdentifier;
    1038. 

  1038. end;
    1039. 

  1039. 

  1040. function TSynCssSyn.Func99: TtkTokenKind;
    1041. 

  1041. begin
    1042. 

  1042.   if KeyComp('word-wrap') then
    1043. 

  1043.     Result := tkKey
    1044. 

  1044.   else
    1045. 

  1045.     Result := tkIdentifier;
    1046. 

  1046. end;
    1047. 

  1047. 

  1048. function TSynCssSyn.Func100: TtkTokenKind;
    1049. 

  1049. begin
    1050. 

  1050.   if KeyComp('stress') then
    1051. 

  1051.     Result := tkKey
    1052. 

  1052.   else
    1053. 

  1053.     Result := tkIdentifier;
    1054. 

  1054. end;
    1055. 

  1055. 

  1056. function TSynCssSyn.Func101: TtkTokenKind;
    1057. 

  1057. begin
    1058. 

  1058.   if KeyComp('voice-family') then
    1059. 

  1059.     Result := tkKey
    1060. 

  1060.   else
    1061. 

  1061.     Result := tkIdentifier;
    1062. 

  1062. end;
    1063. 

  1063. 

  1064. function TSynCssSyn.Func102: TtkTokenKind;
    1065. 

  1065. begin
    1066. 

  1066.   if KeyComp('font-family') or KeyComp('units-per-em') then
    1067. 

  1067.     Result := tkKey
    1068. 

  1068.   else
    1069. 

  1069.     Result := tkIdentifier;
    1070. 

  1070. end;
    1071. 

  1071. 

  1072. function TSynCssSyn.Func103: TtkTokenKind;
    1073. 

  1073. begin
    1074. 

  1074.   if KeyComp('elevation') or KeyComp('@keyframes') or KeyComp('box-orient') then
    1075. 

  1075.     Result := tkKey
    1076. 

  1076.   else
    1077. 

  1077.     Result := tkIdentifier;
    1078. 

  1078. end;
    1079. 

  1079. 

  1080. function TSynCssSyn.Func105: TtkTokenKind;
    1081. 

  1081. begin
    1082. 

  1082.   if KeyComp('margin-right') or KeyComp('border-right') or
    1083. 

  1083.     KeyComp('centerline') then
    1084. 

  1084.     Result := tkKey
    1085. 

  1085.   else
    1086. 

  1086.     Result := tkIdentifier;
    1087. 

  1087. end;
    1088. 

  1088. 

  1089. function TSynCssSyn.Func106: TtkTokenKind;
    1090. 

  1090. begin
    1091. 

  1091.   if KeyComp('border-color') or KeyComp('box-sizing')  then
    1092. 

  1092.     Result := tkKey
    1093. 

  1093.   else
    1094. 

  1094.     Result := tkIdentifier;
    1095. 

  1095. end;
    1096. 

  1096. 

  1097. function TSynCssSyn.Func107: TtkTokenKind;
    1098. 

  1098. begin
    1099. 

  1099.   if KeyComp('border-width') or KeyComp('border-image-slice') or KeyComp('flex-shrink') then
    1100. 

  1100.     Result := tkKey
    1101. 

  1101.   else
    1102. 

  1102.     Result := tkIdentifier;
    1103. 

  1103. end;
    1104. 

  1104. 

  1105. function TSynCssSyn.Func108: TtkTokenKind;
    1106. 

  1106. begin
    1107. 

  1107.   if KeyComp('font-weight') or KeyComp('play-during') or KeyComp('text-wrap')
    1108. 

  1108.   or KeyComp('user-select') then
    1109. 

  1109.     Result := tkKey
    1110. 

  1110.   else
    1111. 

  1111.     Result := tkIdentifier;
    1112. 

  1112. end;
    1113. 

  1113. 

  1114. function TSynCssSyn.Func109: TtkTokenKind;
    1115. 

  1115. begin
    1116. 

  1116.   if KeyComp('column-span') then
    1117. 

  1117.     Result := tkKey
    1118. 

  1118.   else
    1119. 

  1119.     Result := tkIdentifier;
    1120. 

  1120. end;
    1121. 

  1121. 

  1122. function TSynCssSyn.Func110: TtkTokenKind;
    1123. 

  1123. begin
    1124. 

  1124.   if KeyComp('word-spacing') or KeyComp('animation-name') then
    1125. 

  1125.     Result := tkKey
    1126. 

  1126.   else
    1127. 

  1127.     Result := tkIdentifier;
    1128. 

  1128. end;
    1129. 

  1129. 

  1130. function TSynCssSyn.Func111: TtkTokenKind;
    1131. 

  1131. begin
    1132. 

  1132.   if KeyComp('empty-cells') then
    1133. 

  1133.     Result := tkKey
    1134. 

  1134.   else
    1135. 

  1135.     Result := tkIdentifier;
    1136. 

  1136. end;
    1137. 

  1137. 

  1138. function TSynCssSyn.Func112: TtkTokenKind;
    1139. 

  1139. begin
    1140. 

  1140.   if KeyComp('background-image') or KeyComp('border-spacing')
    1141. 

  1141.   or KeyComp('rotation') then
    1142. 

  1142.     Result := tkKey
    1143. 

  1143.   else
    1144. 

  1144.     Result := tkIdentifier;
    1145. 

  1145. end;
    1146. 

  1146. 

  1147. function TSynCssSyn.Func113: TtkTokenKind;
    1148. 

  1148. begin
    1149. 

  1149.   if KeyComp('layout-grid') then
    1150. 

  1150.     Result := tkKey
    1151. 

  1151.   else
    1152. 

  1152.     Result := tkIdentifier;
    1153. 

  1153. end;
    1154. 

  1154. 

  1155. function TSynCssSyn.Func114: TtkTokenKind;
    1156. 

  1156. begin
    1157. 

  1157.   if KeyComp('vertical-align') then
    1158. 

  1158.     Result := tkKey
    1159. 

  1159.   else
    1160. 

  1160.     Result := tkIdentifier;
    1161. 

  1161. end;
    1162. 

  1162. 

  1163. function TSynCssSyn.Func115: TtkTokenKind;
    1164. 

  1164. begin
    1165. 

  1165.   if KeyComp('table-layout') or KeyComp('border-radius')
    1166. 

  1166.   or KeyComp('column-rule') or KeyComp('align-content') then
    1167. 

  1167.     Result := tkKey
    1168. 

  1168.   else
    1169. 

  1169.     Result := tkIdentifier;
    1170. 

  1170. end;
    1171. 

  1171. 

  1172. function TSynCssSyn.Func116: TtkTokenKind;
    1173. 

  1173. begin
    1174. 

  1174.   if KeyComp('text-indent') or KeyComp('overflow') or KeyComp('grid-columns') then
    1175. 

  1175.     Result := tkKey
    1176. 

  1176.   else
    1177. 

  1177.     Result := tkIdentifier;
    1178. 

  1178. end;
    1179. 

  1179. 

  1180. function TSynCssSyn.Func117: TtkTokenKind;
    1181. 

  1181. begin
    1182. 

  1182.   if KeyComp('font-style') or KeyComp('position') or KeyComp('speak-numeral')
    1183. 

  1183.   or KeyComp('background-clip') then
    1184. 

  1184.     Result := tkKey
    1185. 

  1185.   else
    1186. 

  1186.     Result := tkIdentifier;
    1187. 

  1187. end;
    1188. 

  1188. 

  1189. function TSynCssSyn.Func118: TtkTokenKind;
    1190. 

  1190. begin
    1191. 

  1191.   if KeyComp('marker-offset') or KeyComp('writing-mode') then
    1192. 

  1192.     Result := tkKey
    1193. 

  1193.   else
    1194. 

  1194.     Result := tkIdentifier;
    1195. 

  1195. end;
    1196. 

  1196. 

  1197. function TSynCssSyn.Func119: TtkTokenKind;
    1198. 

  1198. begin
    1199. 

  1199.   if KeyComp('box-direction') then
    1200. 

  1200.     Result := tkKey
    1201. 

  1201.   else
    1202. 

  1202.     Result := tkIdentifier;
    1203. 

  1203. end;
    1204. 

  1204. 

  1205. function TSynCssSyn.Func120: TtkTokenKind;
    1206. 

  1206. begin
    1207. 

  1207.   if KeyComp('text-shadow') then
    1208. 

  1208.     Result := tkKey
    1209. 

  1209.   else
    1210. 

  1210.     Result := tkIdentifier;
    1211. 

  1211. end;
    1212. 

  1212. 

  1213. function TSynCssSyn.Func121: TtkTokenKind;
    1214. 

  1214. begin
    1215. 

  1215.   if KeyComp('font-variant') or KeyComp('padding-bottom') or KeyComp('overflow-x') then
    1216. 

  1216.     Result := tkKey
    1217. 

  1217.   else
    1218. 

  1218.     Result := tkIdentifier;
    1219. 

  1219. end;
    1220. 

  1220. 

  1221. function TSynCssSyn.Func122: TtkTokenKind;
    1222. 

  1222. begin
    1223. 

  1223.   if KeyComp('list-style') or KeyComp('overflow-y') then
    1224. 

  1224.     Result := tkKey
    1225. 

  1225.   else
    1226. 

  1226.     Result := tkIdentifier;
    1227. 

  1227. end;
    1228. 

  1228. 

  1229. function TSynCssSyn.Func123: TtkTokenKind;
    1230. 

  1230. begin
    1231. 

  1231.   if KeyComp('border-image-width') or KeyComp('column-width') then
    1232. 

  1232.     Result := tkKey
    1233. 

  1233.   else
    1234. 

  1234.     Result := tkIdentifier;
    1235. 

  1235. end;
    1236. 

  1236. 

  1237. function TSynCssSyn.Func124: TtkTokenKind;
    1238. 

  1238. begin
    1239. 

  1239.   if KeyComp('border-style') or KeyComp('border-image-repeat') or KeyComp('animation-delay')
    1240. 

  1240.      or KeyComp('transform') then Result := tkKey
    1241. 

  1241.   else
    1242. 

  1242.     Result := tkIdentifier;
    1243. 

  1243. end;
    1244. 

  1244. 

  1245. function TSynCssSyn.Func125: TtkTokenKind;
    1246. 

  1246. begin
    1247. 

  1247.   if KeyComp('flex-direction') then
    1248. 

  1248.     Result := tkKey
    1249. 

  1249.   else
    1250. 

  1250.     Result := tkIdentifier;
    1251. 

  1251. end;
    1252. 

  1252. 

  1253. function TSynCssSyn.Func126: TtkTokenKind;
    1254. 

  1254. begin
    1255. 

  1255.   if KeyComp('border-collapse') or KeyComp('definition-src') or KeyComp('text-align-last') then
    1256. 

  1256.     Result := tkKey
    1257. 

  1257.   else
    1258. 

  1258.     Result := tkIdentifier;
    1259. 

  1259. end;
    1260. 

  1260. 

  1261. function TSynCssSyn.Func127: TtkTokenKind;
    1262. 

  1262. begin
    1263. 

  1263.   if KeyComp('box-flex-group') then
    1264. 

  1264.     Result := tkKey
    1265. 

  1265.   else
    1266. 

  1266.     Result := tkIdentifier;
    1267. 

  1267. end;
    1268. 

  1268. 

  1269. function TSynCssSyn.Func128: TtkTokenKind;
    1270. 

  1270. begin
    1271. 

  1271.   if KeyComp('margin-bottom') or KeyComp('border-bottom') or
    1272. 

  1272.     KeyComp('text-kashida-space') then
    1273. 

  1273.     Result := tkKey
    1274. 

  1274.   else
    1275. 

  1275.     Result := tkIdentifier;
    1276. 

  1276. end;
    1277. 

  1277. 

  1278. function TSynCssSyn.Func129: TtkTokenKind;
    1279. 

  1279. begin
    1280. 

  1280.   if KeyComp('font-stretch') then
    1281. 

  1281.     Result := tkKey
    1282. 

  1282.   else
    1283. 

  1283.     Result := tkIdentifier;
    1284. 

  1284. end;
    1285. 

  1285. 

  1286. function TSynCssSyn.Func130: TtkTokenKind;
    1287. 

  1287. begin
    1288. 

  1288.   if KeyComp('border-left-color') or KeyComp('letter-spacing') then
    1289. 

  1289.     Result := tkKey
    1290. 

  1290.   else
    1291. 

  1291.     Result := tkIdentifier;
    1292. 

  1292. end;
    1293. 

  1293. 

  1294. function TSynCssSyn.Func131: TtkTokenKind;
    1295. 

  1295. begin
    1296. 

  1296.   if KeyComp('border-left-width') or KeyComp('layout-grid-mode') then
    1297. 

  1297.     Result := tkKey
    1298. 

  1298.   else
    1299. 

  1299.     Result := tkIdentifier;
    1300. 

  1300. end;
    1301. 

  1301. 

  1302. function TSynCssSyn.Func132: TtkTokenKind;
    1303. 

  1303. begin
    1304. 

  1304.   if KeyComp('column-count') then
    1305. 

  1305.     Result := tkKey
    1306. 

  1306.   else
    1307. 

  1307.     Result := tkIdentifier;
    1308. 

  1308. end;
    1309. 

  1309. 

  1310. function TSynCssSyn.Func134: TtkTokenKind;
    1311. 

  1311. begin
    1312. 

  1312.   if KeyComp('layout-grid-line') or KeyComp('animation-fill-mode') then
    1313. 

  1313.     Result := tkKey
    1314. 

  1314.   else
    1315. 

  1315.     Result := tkIdentifier;
    1316. 

  1316. end;
    1317. 

  1317. 

  1318. function TSynCssSyn.Func136: TtkTokenKind;
    1319. 

  1319. begin
    1320. 

  1320.   if KeyComp('visibility') or KeyComp('background-size') then
    1321. 

  1321.     Result := tkKey
    1322. 

  1322.   else
    1323. 

  1323.     Result := tkIdentifier;
    1324. 

  1324. end;
    1325. 

  1325. 

  1326. function TSynCssSyn.Func137: TtkTokenKind;
    1327. 

  1327. begin
    1328. 

  1328.   if KeyComp('ruby-overhang') then
    1329. 

  1329.     Result := tkKey
    1330. 

  1330.   else
    1331. 

  1331.     Result := tkIdentifier;
    1332. 

  1332. end;
    1333. 

  1333. 

  1334. function TSynCssSyn.Func138: TtkTokenKind;
    1335. 

  1335. begin
    1336. 

  1336.   if KeyComp('border-top-color') or KeyComp('list-style-image') or KeyComp('perspective') then
    1337. 

  1337.     Result := tkKey
    1338. 

  1338.   else
    1339. 

  1339.     Result := tkIdentifier;
    1340. 

  1340. end;
    1341. 

  1341. 

  1342. function TSynCssSyn.Func139: TtkTokenKind;
    1343. 

  1343. begin
    1344. 

  1344.   if KeyComp('border-top-width') or KeyComp('transition') then
    1345. 

  1345.     Result := tkKey
    1346. 

  1346.   else
    1347. 

  1347.     Result := tkIdentifier;
    1348. 

  1348. end;
    1349. 

  1349. 

  1350. function TSynCssSyn.Func140: TtkTokenKind;
    1351. 

  1351. begin
    1352. 

  1352.   if KeyComp('background-color') or KeyComp('outline-color') or KeyComp('text-emphasis') or
    1353. 

  1353.     KeyComp('scrollbar-face-color') or KeyComp('border-image-source') then
    1354. 

  1354.     Result := tkKey
    1355. 

  1355.   else
    1356. 

  1356.     Result := tkIdentifier;
    1357. 

  1357. end;
    1358. 

  1358. 

  1359. function TSynCssSyn.Func141: TtkTokenKind;
    1360. 

  1360. begin
    1361. 

  1361.   if KeyComp('outline-width') then
    1362. 

  1362.     Result := tkKey
    1363. 

  1363.   else
    1364. 

  1364.     Result := tkIdentifier;
    1365. 

  1365. end;
    1366. 

  1366. 

  1367. function TSynCssSyn.Func142: TtkTokenKind;
    1368. 

  1368. begin
    1369. 

  1369.   if KeyComp('background-repeat') then
    1370. 

  1370.     Result := tkKey
    1371. 

  1371.   else
    1372. 

  1372.     Result := tkIdentifier;
    1373. 

  1373. end;
    1374. 

  1374. 

  1375. function TSynCssSyn.Func144: TtkTokenKind;
    1376. 

  1376. begin
    1377. 

  1377.   if KeyComp('counter-reset') or KeyComp('box-decoration-break') or KeyComp('@supports') then
    1378. 

  1378.     Result := tkKey
    1379. 

  1379.   else
    1380. 

  1380.     Result := tkIdentifier;
    1381. 

  1381. end;
    1382. 

  1382. 

  1383. function TSynCssSyn.Func146: TtkTokenKind;
    1384. 

  1384. begin
    1385. 

  1385.   if KeyComp('text-outline') then
    1386. 

  1386.     Result := tkKey
    1387. 

  1387.   else
    1388. 

  1388.     Result := tkIdentifier;
    1389. 

  1389. end;
    1390. 

  1390. 

  1391. function TSynCssSyn.Func148: TtkTokenKind;
    1392. 

  1392. begin
    1393. 

  1393.   if KeyComp('border-left-style') or KeyComp('outline-offset') then
    1394. 

  1394.     Result := tkKey
    1395. 

  1395.   else
    1396. 

  1396.     Result := tkIdentifier;
    1397. 

  1397. end;
    1398. 

  1398. 

  1399. function TSynCssSyn.Func149: TtkTokenKind;
    1400. 

  1400. begin
    1401. 

  1401.   if KeyComp('border-right-color') or KeyComp('background-origin') or KeyComp('backface-visibility') then
    1402. 

  1402.     Result := tkKey
    1403. 

  1403.   else
    1404. 

  1404.     Result := tkIdentifier;
    1405. 

  1405. end;
    1406. 

  1406. 

  1407. function TSynCssSyn.Func150: TtkTokenKind;
    1408. 

  1408. begin
    1409. 

  1409.   if KeyComp('border-right-width') then
    1410. 

  1410.     Result := tkKey
    1411. 

  1411.   else
    1412. 

  1412.     Result := tkIdentifier;
    1413. 

  1413. end;
    1414. 

  1414. 

  1415. function TSynCssSyn.Func151: TtkTokenKind;
    1416. 

  1416. begin
    1417. 

  1417.   if KeyComp('font-size-adjust') or KeyComp('text-autospace') then
    1418. 

  1418.     Result := tkKey
    1419. 

  1419.   else
    1420. 

  1420.     Result := tkIdentifier;
    1421. 

  1421. end;
    1422. 

  1422. 

  1423. function TSynCssSyn.Func152: TtkTokenKind;
    1424. 

  1424. begin
    1425. 

  1425.   if KeyComp('scrollbar-base-color') then
    1426. 

  1426.     Result := tkKey
    1427. 

  1427.   else
    1428. 

  1428.     Result := tkIdentifier;
    1429. 

  1429. end;
    1430. 

  1430. 

  1431. function TSynCssSyn.Func153: TtkTokenKind;
    1432. 

  1432. begin
    1433. 

  1433.   if KeyComp('box-ordinal-group') or KeyComp('object-position') then
    1434. 

  1434.     Result := tkKey
    1435. 

  1435.   else
    1436. 

  1436.     Result := tkIdentifier;
    1437. 

  1437. end;
    1438. 

  1438. 

  1439. function TSynCssSyn.Func154: TtkTokenKind;
    1440. 

  1440. begin
    1441. 

  1441.   if KeyComp('text-decoration') then
    1442. 

  1442.     Result := tkKey
    1443. 

  1443.   else
    1444. 

  1444.     Result := tkIdentifier;
    1445. 

  1445. end;
    1446. 

  1446. 

  1447. function TSynCssSyn.Func156: TtkTokenKind;
    1448. 

  1448. begin
    1449. 

  1449.   if KeyComp('border-top-style') then
    1450. 

  1450.     Result := tkKey
    1451. 

  1451.   else
    1452. 

  1452.     Result := tkIdentifier;
    1453. 

  1453. end;
    1454. 

  1454. 

  1455. function TSynCssSyn.Func158: TtkTokenKind;
    1456. 

  1456. begin
    1457. 

  1457.   if KeyComp('outline-style') then
    1458. 

  1458.     Result := tkKey
    1459. 

  1459.   else
    1460. 

  1460.     Result := tkIdentifier;
    1461. 

  1461. end;
    1462. 

  1462. 

  1463. function TSynCssSyn.Func159: TtkTokenKind;
    1464. 

  1464. begin
    1465. 

  1465.   if KeyComp('border-image-outset') or KeyComp('column-rule-color') then
    1466. 

  1466.     Result := tkKey
    1467. 

  1467.   else
    1468. 

  1468.     Result := tkIdentifier;
    1469. 

  1469. end;
    1470. 

  1470. 

  1471. function TSynCssSyn.Func160: TtkTokenKind;
    1472. 

  1472. begin
    1473. 

  1473.   if KeyComp('layout-grid-type') or KeyComp('text-justify')
    1474. 

  1474.   or KeyComp('column-rule-width') then
    1475. 

  1475.     Result := tkKey
    1476. 

  1476.   else
    1477. 

  1477.     Result := tkIdentifier;
    1478. 

  1478. end;
    1479. 

  1479. 

  1480. function TSynCssSyn.Func164: TtkTokenKind;
    1481. 

  1481. begin
    1482. 

  1482.   if KeyComp('ruby-position') then
    1483. 

  1483.     Result := tkKey
    1484. 

  1484.   else
    1485. 

  1485.     Result := tkIdentifier;
    1486. 

  1486. end;
    1487. 

  1487. 

  1488. function TSynCssSyn.Func166: TtkTokenKind;
    1489. 

  1489. begin
    1490. 

  1490.   if KeyComp('scrollbar-3d-light-color') or KeyComp('text-overflow') then
    1491. 

  1491.     Result := tkKey
    1492. 

  1492.   else
    1493. 

  1493.     Result := tkIdentifier;
    1494. 

  1494. end;
    1495. 

  1495. 

  1496. function TSynCssSyn.Func167: TtkTokenKind;
    1497. 

  1497. begin
    1498. 

  1498.   if KeyComp('border-right-style') or KeyComp('rotation-point')
    1499. 

  1499.   or KeyComp('transition-delay') then
    1500. 

  1500.     Result := tkKey
    1501. 

  1501.   else
    1502. 

  1502.     Result := tkIdentifier;
    1503. 

  1503. end;
    1504. 

  1504. 

  1505. function TSynCssSyn.Func169: TtkTokenKind;
    1506. 

  1506. begin
    1507. 

  1507.   if KeyComp('list-style-type') or KeyComp('target-position') then
    1508. 

  1508.     Result := tkKey
    1509. 

  1509.   else
    1510. 

  1510.     Result := tkIdentifier;
    1511. 

  1511. end;
    1512. 

  1512. 

  1513. function TSynCssSyn.Func171: TtkTokenKind;
    1514. 

  1514. begin
    1515. 

  1515.   if KeyComp('border-top-left-radius') then
    1516. 

  1516.     Result := tkKey
    1517. 

  1517.   else
    1518. 

  1518.     Result := tkIdentifier;
    1519. 

  1519. end;
    1520. 

  1520. 

  1521. function TSynCssSyn.Func172: TtkTokenKind;
    1522. 

  1522. begin
    1523. 

  1523.   if KeyComp('border-bottom-color') then
    1524. 

  1524.     Result := tkKey
    1525. 

  1525.   else
    1526. 

  1526.     Result := tkIdentifier;
    1527. 

  1527. end;
    1528. 

  1528. 

  1529. function TSynCssSyn.Func173: TtkTokenKind;
    1530. 

  1530. begin
    1531. 

  1531.   if KeyComp('border-bottom-width') then
    1532. 

  1532.     Result := tkKey
    1533. 

  1533.   else
    1534. 

  1534.     Result := tkIdentifier;
    1535. 

  1535. end;
    1536. 

  1536. 

  1537. function TSynCssSyn.Func174: TtkTokenKind;
    1538. 

  1538. begin
    1539. 

  1539.   if KeyComp('text-transform') or KeyComp('animation-direction') then
    1540. 

  1540.     Result := tkKey
    1541. 

  1541.   else
    1542. 

  1542.     Result := tkIdentifier;
    1543. 

  1543. end;
    1544. 

  1544. 

  1545. function TSynCssSyn.Func175: TtkTokenKind;
    1546. 

  1546. begin
    1547. 

  1547.   if KeyComp('text-decoration-line') then
    1548. 

  1548.     Result := tkKey
    1549. 

  1549.   else
    1550. 

  1550.     Result := tkIdentifier;
    1551. 

  1551. end;
    1552. 

  1552. 

  1553. function TSynCssSyn.Func177: TtkTokenKind;
    1554. 

  1554. begin
    1555. 

  1555.   if KeyComp('animation-play-state') or KeyComp('column-rule-style')
    1556. 

  1556.   or KeyComp('transform-origin') then
    1557. 

  1557.     Result := tkKey
    1558. 

  1558.   else
    1559. 

  1559.     Result := tkIdentifier;
    1560. 

  1560. end;
    1561. 

  1561. 

  1562. function TSynCssSyn.Func178: TtkTokenKind;
    1563. 

  1563. begin
    1564. 

  1564.   if KeyComp('counter-increment') or KeyComp('overflow-style') then
    1565. 

  1565.     Result := tkKey
    1566. 

  1566.   else
    1567. 

  1567.     Result := tkIdentifier;
    1568. 

  1568. end;
    1569. 

  1569. 

  1570. function TSynCssSyn.Func179: TtkTokenKind;
    1571. 

  1571. begin
    1572. 

  1572.   if KeyComp('animation-duration') then
    1573. 

  1573.     Result := tkKey
    1574. 

  1574.   else
    1575. 

  1575.     Result := tkIdentifier;
    1576. 

  1576. end;
    1577. 

  1577. 

  1578. function TSynCssSyn.Func182: TtkTokenKind;
    1579. 

  1579. begin
    1580. 

  1580.   if KeyComp('background-attachment') or KeyComp('justify-content') then
    1581. 

  1581.     Result := tkKey
    1582. 

  1582.   else
    1583. 

  1583.     Result := tkIdentifier;
    1584. 

  1584. end;
    1585. 

  1585. 

  1586. function TSynCssSyn.Func186: TtkTokenKind;
    1587. 

  1587. begin
    1588. 

  1588.   if KeyComp('transform-style') then
    1589. 

  1589.     Result := tkKey
    1590. 

  1590.   else
    1591. 

  1591.     Result := tkIdentifier;
    1592. 

  1592. end;
    1593. 

  1593. 

  1594. function TSynCssSyn.Func187: TtkTokenKind;
    1595. 

  1595. begin
    1596. 

  1596.   if KeyComp('speak-punctuation') then
    1597. 

  1597.     Result := tkKey
    1598. 

  1598.   else
    1599. 

  1599.     Result := tkIdentifier;
    1600. 

  1600. end;
    1601. 

  1601. 

  1602. function TSynCssSyn.Func190: TtkTokenKind;
    1603. 

  1603. begin
    1604. 

  1604.   if KeyComp('border-bottom-style') or KeyComp('border-top-right-radius') then
    1605. 

  1605.     Result := tkKey
    1606. 

  1606.   else
    1607. 

  1607.     Result := tkIdentifier;
    1608. 

  1608. end;
    1609. 

  1609. 

  1610. function TSynCssSyn.Func191: TtkTokenKind;
    1611. 

  1611. begin
    1612. 

  1612.   if KeyComp('perspective-origin') then
    1613. 

  1613.     Result := tkKey
    1614. 

  1614.   else
    1615. 

  1615.     Result := tkIdentifier;
    1616. 

  1616. end;
    1617. 

  1617. 

  1618. function TSynCssSyn.Func194: TtkTokenKind;
    1619. 

  1619. begin
    1620. 

  1620.   if KeyComp('background-position') then
    1621. 

  1621.     Result := tkKey
    1622. 

  1622.   else
    1623. 

  1623.     Result := tkIdentifier;
    1624. 

  1624. end;
    1625. 

  1625. 

  1626. function TSynCssSyn.Func195: TtkTokenKind;
    1627. 

  1627. begin
    1628. 

  1628.   if KeyComp('scrollbar-shadow-color') or KeyComp('hanging-punctuation')
    1629. 

  1629.     or KeyComp('punctuation-trim') then
    1630. 

  1630.     Result := tkKey
    1631. 

  1631.   else
    1632. 

  1632.     Result := tkIdentifier;
    1633. 

  1633. end;
    1634. 

  1634. 

  1635. function TSynCssSyn.Func198: TtkTokenKind;
    1636. 

  1636. begin
    1637. 

  1637.   if KeyComp('text-decoration-color') then
    1638. 

  1638.     Result := tkKey
    1639. 

  1639.   else
    1640. 

  1640.     Result := tkIdentifier;
    1641. 

  1641. end;
    1642. 

  1642. 

  1643. function TSynCssSyn.Func199: TtkTokenKind;
    1644. 

  1644. begin
    1645. 

  1645.   if KeyComp('background-position-x') then
    1646. 

  1646.     Result := tkKey
    1647. 

  1647.   else
    1648. 

  1648.     Result := tkIdentifier;
    1649. 

  1649. end;
    1650. 

  1650. 

  1651. function TSynCssSyn.Func200: TtkTokenKind;
    1652. 

  1652. begin
    1653. 

  1653.   if KeyComp('background-position-y') or KeyComp('scrollbar-arrow-color') then
    1654. 

  1654.     Result := tkKey
    1655. 

  1655.   else
    1656. 

  1656.     Result := tkIdentifier;
    1657. 

  1657. end;
    1658. 

  1658. 

  1659. function TSynCssSyn.Func205: TtkTokenKind;
    1660. 

  1660. begin
    1661. 

  1661.   if KeyComp('border-bottom-left-radius') then
    1662. 

  1662.     Result := tkKey
    1663. 

  1663.   else
    1664. 

  1664.     Result := tkIdentifier;
    1665. 

  1665. end;
    1666. 

  1666. 

  1667. function TSynCssSyn.Func210: TtkTokenKind;
    1668. 

  1668. begin
    1669. 

  1669.   if KeyComp('scrollbar-dark-shadow-color') then
    1670. 

  1670.     Result := tkKey
    1671. 

  1671.   else
    1672. 

  1672.     Result := tkIdentifier;
    1673. 

  1673. end;
    1674. 

  1674. 

  1675. function TSynCssSyn.Func213: TtkTokenKind;
    1676. 

  1676. begin
    1677. 

  1677.   if KeyComp('scrollbar-highlight-color') then
    1678. 

  1678.     Result := tkKey
    1679. 

  1679.   else
    1680. 

  1680.     Result := tkIdentifier;
    1681. 

  1681. end;
    1682. 

  1682. 

  1683. function TSynCssSyn.Func216: TtkTokenKind;
    1684. 

  1684. begin
    1685. 

  1685.   if KeyComp('text-decoration-style') then
    1686. 

  1686.     Result := tkKey
    1687. 

  1687.   else
    1688. 

  1688.     Result := tkIdentifier;
    1689. 

  1689. end;
    1690. 

  1690. 

  1691. function TSynCssSyn.Func220: TtkTokenKind;
    1692. 

  1692. begin
    1693. 

  1693.   if KeyComp('list-style-position') then
    1694. 

  1694.     Result := tkKey
    1695. 

  1695.   else
    1696. 

  1696.     Result := tkIdentifier;
    1697. 

  1697. end;
    1698. 

  1698. 

  1699. function TSynCssSyn.Func222: TtkTokenKind;
    1700. 

  1700. begin
    1701. 

  1701.   if KeyComp('transition-duration') then
    1702. 

  1702.     Result := tkKey
    1703. 

  1703.   else
    1704. 

  1704.     Result := tkIdentifier;
    1705. 

  1705. end;
    1706. 

  1706. 

  1707. function TSynCssSyn.Func224: TtkTokenKind;
    1708. 

  1708. begin
    1709. 

  1709.   if KeyComp('border-bottom-right-radius') then
    1710. 

  1710.     Result := tkKey
    1711. 

  1711.   else
    1712. 

  1712.     Result := tkIdentifier;
    1713. 

  1713. end;
    1714. 

  1714. 

  1715. function TSynCssSyn.Func232: TtkTokenKind;
    1716. 

  1716. begin
    1717. 

  1717.   if KeyComp('animation-timing-function') then
    1718. 

  1718.     Result := tkKey
    1719. 

  1719.   else
    1720. 

  1720.     Result := tkIdentifier;
    1721. 

  1721. end;
    1722. 

  1722. 

  1723. function TSynCssSyn.Func242: TtkTokenKind;
    1724. 

  1724. begin
    1725. 

  1725.   if KeyComp('animation-iteration-count') then
    1726. 

  1726.     Result := tkKey
    1727. 

  1727.   else
    1728. 

  1728.     Result := tkIdentifier;
    1729. 

  1729. end;
    1730. 

  1730. 

  1731. function TSynCssSyn.Func250: TtkTokenKind;
    1732. 

  1732. begin
    1733. 

  1733.   if KeyComp('text-underline-position') then
    1734. 

  1734.     Result := tkKey
    1735. 

  1735.   else
    1736. 

  1736.     Result := tkIdentifier;
    1737. 

  1737. end;
    1738. 

  1738. 

  1739. function TSynCssSyn.Func253: TtkTokenKind;
    1740. 

  1740. begin
    1741. 

  1741.   if KeyComp('transition-property') then
    1742. 

  1742.     Result := tkKey
    1743. 

  1743.   else
    1744. 

  1744.     Result := tkIdentifier;
    1745. 

  1745. end;
    1746. 

  1746. 

  1747. function TSynCssSyn.Func275: TtkTokenKind;
    1748. 

  1748. begin
    1749. 

  1749.   if KeyComp('transition-timing-function') then
    1750. 

  1750.     Result := tkKey
    1751. 

  1751.   else
    1752. 

  1752.     Result := tkIdentifier;
    1753. 

  1753. end;
    1754. 

  1754. 

  1755. function TSynCssSyn.AltFunc: TtkTokenKind;
    1756. 

  1756. begin
    1757. 

  1757.   Result := tkIdentifier;
    1758. 

  1758. end;
    1759. 

  1759. 

  1760. function TSynCssSyn.IdentKind(MayBe: PChar): TtkTokenKind;
    1761. 

  1761. var
    1762. 

  1762.   HashKey: Integer;
    1763. 

  1763. begin
    1764. 

  1764.   FToIdent := MayBe;
    1765. 

  1765.   HashKey := KeyHash(MayBe);
    1766. 

  1766.   if (HashKey >= 16) and (HashKey <= 275) then
    1767. 

  1767.     Result := fIdentFuncTable[HashKey]()
    1768. 

  1768.   else
    1769. 

  1769.     Result := tkIdentifier;
    1770. 

  1770. end;
    1771. 

  1771. 

  1772. procedure TSynCssSyn.MakeMethodTables;
    1773. 

  1773. var
    1774. 

  1774.   chI: Char;
    1775. 

  1775. begin
    1776. 

  1776.   for chI := #0 to #255 do
    1777. 

  1777.     case chI of
    1778. 

  1778.       '{'                         : FProcTable[chI] := @CurlyOpenProc;
    1779. 

  1779.       '}'                         : FProcTable[chI] := @CurlyCloseProc;
    1780. 

  1780.       ';'                         : FProcTable[chI] := @SymbolProc;
    1781. 

  1781.       ':'                         : FProcTable[chI] := @ColonProc;
    1782. 

  1782.       '.', '*', ',','>','+','~'   : FProcTable[chI] := @SelectorProc;
    1783. 

  1783.       '%'                         : FProcTable[chI] := @PercentProc;
    1784. 

  1784.       #13                         : FProcTable[chI] := @CRProc;
    1785. 

  1785.       '-'                         : FProcTable[chI] := @DashProc;
    1786. 

  1786.       'A'..'Z', 'a'..'z', '_','@' : FProcTable[chI] := @IdentProc;
    1787. 

  1787.       '#'                         : FProcTable[chI] := @HashProc;
    1788. 

  1788.       '$'                         : FProcTable[chI] := @IntegerProc;
    1789. 

  1789.       #10                         : FProcTable[chI] := @LFProc;
    1790. 

  1790.       #0                          : FProcTable[chI] := @NullProc;
    1791. 

  1791.       '0'..'9'                    : FProcTable[chI] := @NumberProc;
    1792. 

  1792.       ')', '('                    : FProcTable[chI] := @RoundOpenProc;
    1793. 

  1793.       '/'                         : FProcTable[chI] := @SlashProc;
    1794. 

  1794.       #1..#9, #11, #12, #14..#32  : FProcTable[chI] := @SpaceProc;
    1795. 

  1795.       #39                         : FProcTable[chI] := @StringProc;
    1796. 

  1796.     else
    1797. 

  1797.       FProcTable[chI] := @UnknownProc;
    1798. 

  1798.     end;
    1799. 

  1799. end;
    1800. 

  1800. 

  1801. constructor TSynCssSyn.Create(AOwner: TComponent);
    1802. 

  1802. begin
    1803. 

  1803.   inherited Create(AOwner);
    1804. 

  1804.   fCommentAttri := TSynHighlighterAttributes.Create(@SYNS_AttrComment, SYNS_XML_AttrComment);
    1805. 

  1805.   fCommentAttri.Style := [fsItalic];
    1806. 

  1806.   AddAttribute(fCommentAttri);
    1807. 

  1807.   fIdentifierAttri := TSynHighlighterAttributes.Create(@SYNS_AttrIdentifier, SYNS_XML_AttrIdentifier);
    1808. 

  1808.   AddAttribute(fIdentifierAttri);
    1809. 

  1809.   fKeyAttri := TSynHighlighterAttributes.Create(@SYNS_AttrKey, SYNS_XML_AttrKey);
    1810. 

  1810.   fKeyAttri.Style := [fsBold];
    1811. 

  1811.   AddAttribute(fKeyAttri);
    1812. 

  1812.   fNumberAttri := TSynHighlighterAttributes.Create(@SYNS_AttrNumber, SYNS_XML_AttrNumber);
    1813. 

  1813.   AddAttribute(fNumberAttri);
    1814. 

  1814.   fSpaceAttri := TSynHighlighterAttributes.Create(@SYNS_AttrSpace, SYNS_XML_AttrSpace);
    1815. 

  1815.   AddAttribute(fSpaceAttri);
    1816. 

  1816.   fStringAttri := TSynHighlighterAttributes.Create(@SYNS_AttrString, SYNS_XML_AttrString);
    1817. 

  1817.   AddAttribute(fStringAttri);
    1818. 

  1818.   fSymbolAttri := TSynHighlighterAttributes.Create(@SYNS_AttrSymbol, SYNS_XML_AttrSymbol);
    1819. 

  1819.   AddAttribute(fSymbolAttri);
    1820. 

  1820.   fMeasurementUnitAttri := TSynHighlighterAttributes.Create(@SYNS_AttrMeasurementUnitValue, SYNS_XML_AttrMeasurementUnitValue);
    1821. 

  1821.   AddAttribute(fMeasurementUnitAttri);
    1822. 

  1822.   fSelectorAttri := TSynHighlighterAttributes.Create(@SYNS_AttrSelectorValue, SYNS_XML_AttrSelectorValue);
    1823. 

  1823.   AddAttribute(fSelectorAttri);
    1824. 

  1824.   SetAttributesOnChange(@DefHighlightChange);
    1825. 

  1825.   InitIdent;
    1826. 

  1826.   MakeMethodTables;
    1827. 

  1827.   fDefaultFilter := SYNS_FilterCSS;
    1828. 

  1828.   fRange := [];
    1829. 

  1829. end;
    1830. 

  1830. 

  1831. procedure TSynCssSyn.SetLine(const NewValue: String; LineNumber: Integer);
    1832. 

  1832. begin
    1833. 

  1833.   inherited;
    1834. 

  1834.   fLine := PChar(NewValue);
    1835. 

  1835.   Run := 0;
    1836. 

  1836.   fLineNumber := LineNumber;
    1837. 

  1837.   Next;
    1838. 

  1838. end;
    1839. 

  1839. 

  1840. procedure TSynCssSyn.SymbolProc;
    1841. 

  1841. begin
    1842. 

  1842.   if rsInDeclarationBlock in fRange then
    1843. 

  1843.     FTokenID := tkSymbol
    1844. 

  1844.   else
    1845. 

  1845.     FTokenID := tkIdentifier;
    1846. 

  1846.   Inc(Run);
    1847. 

  1847. end;
    1848. 

  1848. 

  1849. procedure TSynCssSyn.ColonProc;
    1850. 

  1850. begin
    1851. 

  1851.   if not(rsInDeclarationBlock in fRange) then
    1852. 

  1852.     FTokenID := tkSelector
    1853. 

  1853.   else
    1854. 

  1854.     FTokenID := tkSymbol;
    1855. 

  1855.   Inc(Run);
    1856. 

  1856. end;
    1857. 

  1857. 

  1858. procedure TSynCssSyn.SelectorProc;
    1859. 

  1859. begin
    1860. 

  1860.   if not(rsInDeclarationBlock in fRange) then
    1861. 

  1861.     FTokenID := tkSelector
    1862. 

  1862.   else
    1863. 

  1863.     FTokenID := tkIdentifier;
    1864. 

  1864.   Inc(Run);
    1865. 

  1865. end;
    1866. 

  1866. 

  1867. procedure TSynCssSyn.PercentProc;
    1868. 

  1868. begin
    1869. 

  1869.   if rsInDeclarationBlock in fRange then
    1870. 

  1870.     FTokenID := tkMeasurementUnit
    1871. 

  1871.   else
    1872. 

  1872.     FTokenID := tkIdentifier;
    1873. 

  1873.   Inc(Run);
    1874. 

  1874. end;
    1875. 

  1875. 

  1876. procedure TSynCssSyn.CurlyOpenProc;
    1877. 

  1877. begin
    1878. 

  1878.   FTokenID := tkSymbol;
    1879. 

  1879.   Inc(Run);
    1880. 

  1880.   fRange := fRange + [rsInDeclarationBlock];
    1881. 

  1881. end;
    1882. 

  1882. 

  1883. procedure TSynCssSyn.CurlyCloseProc;
    1884. 

  1884. begin
    1885. 

  1885.   FTokenID := tkSymbol;
    1886. 

  1886.   Inc(Run);
    1887. 

  1887.   fRange := fRange - [rsInDeclarationBlock];
    1888. 

  1888. end;
    1889. 

  1889. 

  1890. procedure TSynCssSyn.CRProc;
    1891. 

  1891. begin
    1892. 

  1892.   FTokenID := tkSpace;
    1893. 

  1893.   Inc(Run);
    1894. 

  1894.   if FLine[Run] = #10 then
    1895. 

  1895.     Inc(Run);
    1896. 

  1896. end;
    1897. 

  1897. 

  1898. procedure TSynCssSyn.CStyleCommentProc;
    1899. 

  1899. begin
    1900. 

  1900.   if FLine[Run] = #0 then
    1901. 

  1901.     FTokenID := tkNull
    1902. 

  1902.   else begin
    1903. 

  1903.     FTokenID := tkComment;
    1904. 

  1904.     repeat
    1905. 

  1905.       if (fLine[Run] = '*') and (fLine[Run + 1] = '/') then begin
    1906. 

  1906.         FRange := fRange - [rsCStyle];
    1907. 

  1907.         Inc(Run, 2);
    1908. 

  1908.         Break;
    1909. 

  1909.       end;
    1910. 

  1910.       Inc(Run);
    1911. 

  1911.     until FLine[Run] in [#0, #10, #13];
    1912. 

  1912.   end;
    1913. 

  1913. end;
    1914. 

  1914. 

  1915. procedure TSynCssSyn.DashProc;
    1916. 

  1916. begin
    1917. 

  1917.   if (FLine[Run - 1] = ' ') then begin
    1918. 

  1918.     if (FLine[Run + 1] in ['0'..'9', 'a'..'z', 'A'..'Z']) then
    1919. 

  1919.       FTokenID := tkNumber
    1920. 

  1920.     else if (FLine[Run + 1] = '.') and (FLine[Run + 2] in ['0'..'9', 'a'..'z', 'A'..'Z']) then begin
    1921. 

  1921.       FTokenID := tkNumber;
    1922. 

  1922.       Inc(Run);
    1923. 

  1923.     end;
    1924. 

  1924.   end else
    1925. 

  1925.     FTokenID := tkIdentifier;
    1926. 

  1926.   Inc(Run);
    1927. 

  1927. end;
    1928. 

  1928. 

  1929. procedure TSynCssSyn.IdentProc;
    1930. 

  1930. begin
    1931. 

  1931.   FTokenID := IdentKind((FLine + Run));
    1932. 

  1932.   Inc(Run, FStringLen);
    1933. 

  1933.   while Identifiers[FLine[Run]] do
    1934. 

  1934.     Inc(Run);
    1935. 

  1935. end;
    1936. 

  1936. 

  1937. procedure TSynCssSyn.HashProc;
    1938. 

  1938. begin
    1939. 

  1939.   if (rsInDeclarationBlock in fRange) then begin
    1940. 

  1940.     IntegerProc;
    1941. 

  1941.     exit;
    1942. 

  1942.   end;
    1943. 

  1943. 

  1944.   Inc(Run);
    1945. 

  1945.   FTokenID := tkSelector;
    1946. 

  1946. end;
    1947. 

  1947. 

  1948. procedure TSynCssSyn.IntegerProc;
    1949. 

  1949. begin
    1950. 

  1950.   Inc(Run);
    1951. 

  1951.   if not(rsInDeclarationBlock in fRange) then begin
    1952. 

  1952.     FTokenID := tkIdentifier;
    1953. 

  1953.     exit;
    1954. 

  1954.   end;
    1955. 

  1955. 

  1956.   FTokenID := tkNumber;
    1957. 

  1957.   while FLine[Run] in ['0'..'9', 'A'..'F', 'a'..'f'] do
    1958. 

  1958.     Inc(Run);
    1959. 

  1959. end;
    1960. 

  1960. 

  1961. procedure TSynCssSyn.LFProc;
    1962. 

  1962. begin
    1963. 

  1963.   FTokenID := tkSpace;
    1964. 

  1964.   Inc(Run);
    1965. 

  1965. end;
    1966. 

  1966. 

  1967. procedure TSynCssSyn.NullProc;
    1968. 

  1968. begin
    1969. 

  1969.   FTokenID := tkNull;
    1970. 

  1970. end;
    1971. 

  1971. 

  1972. procedure TSynCssSyn.NumberProc;
    1973. 

  1973. begin
    1974. 

  1974.   Inc(Run);
    1975. 

  1975.   FTokenID := tkNumber;
    1976. 

  1976.   while FLine[Run] in ['0'..'9', '.', 'e', 'E'] do begin
    1977. 

  1977.     if ((FLine[Run] = '.') and (FLine[Run + 1] = '.')) or
    1978. 

  1978.        ((FLine[Run] = 'e') and ((FLine[Run + 1] = 'x') or (FLine[Run + 1] = 'm'))) then
    1979. 

  1979.       Break;
    1980. 

  1980.     Inc(Run);
    1981. 

  1981.   end;
    1982. 

  1982. end;
    1983. 

  1983. 

  1984. procedure TSynCssSyn.RoundOpenProc;
    1985. 

  1985. begin
    1986. 

  1986.   Inc(Run);
    1987. 

  1987.   FTokenID := tkSymbol;
    1988. 

  1988. end;
    1989. 

  1989. 

  1990. procedure TSynCssSyn.SlashProc;
    1991. 

  1991. begin
    1992. 

  1992.   Inc(Run);
    1993. 

  1993.   if fLine[Run] = '*' then begin
    1994. 

  1994.     FTokenID := tkComment;
    1995. 

  1995.     FRange := fRange + [rsCStyle];
    1996. 

  1996.     Inc(Run);
    1997. 

  1997.     if not (FLine[Run] in [#0, #10, #13]) then
    1998. 

  1998.       CStyleCommentProc;
    1999. 

  1999.   end else
    2000. 

  2000.     FTokenID := tkIdentifier;
    2001. 

  2001. end;
    2002. 

  2002. 

  2003. procedure TSynCssSyn.SpaceProc;
    2004. 

  2004. begin
    2005. 

  2005.   Inc(Run);
    2006. 

  2006.   FTokenID := tkSpace;
    2007. 

  2007.   while FLine[Run] in [#1..#9, #11, #12, #14..#32] do
    2008. 

  2008.     Inc(Run);
    2009. 

  2009. end;
    2010. 

  2010. 

  2011. procedure TSynCssSyn.StringProc;
    2012. 

  2012. begin
    2013. 

  2013.   FTokenID := tkString;
    2014. 

  2014.   if (FLine[Run + 1] = #39) and (FLine[Run + 2] = #39) then
    2015. 

  2015.     Inc(Run, 2);
    2016. 

  2016.   repeat
    2017. 

  2017.     case FLine[Run] of
    2018. 

  2018.       #0, #10, #13: Break;
    2019. 

  2019.     end;
    2020. 

  2020.     Inc(Run);
    2021. 

  2021.   until FLine[Run] = #39;
    2022. 

  2022.   if FLine[Run] <> #0 then
    2023. 

  2023.     Inc(Run);
    2024. 

  2024. end;
    2025. 

  2025. 

  2026. procedure TSynCssSyn.UnknownProc;
    2027. 

  2027. begin
    2028. 

  2028. {$IFDEF SYN_MBCSSUPPORT}
    2029. 

  2029.   if FLine[Run] in LeadBytes then
    2030. 

  2030.     Inc(Run,2)
    2031. 

  2031.   else
    2032. 

  2032. {$ENDIF}
    2033. 

  2033.   Inc(Run);
    2034. 

  2034.   while (fLine[Run] in [#128..#191]) OR // continued utf8 subcode
    2035. 

  2035.    ((fLine[Run]<>#0) and (fProcTable[fLine[Run]] = @UnknownProc)) do inc(Run);
    2036. 

  2036.   FTokenID := tkUnknown;
    2037. 

  2037. end;
    2038. 

  2038. 

  2039. procedure TSynCssSyn.Next;
    2040. 

  2040. begin
    2041. 

  2041.   FTokenPos := Run;
    2042. 

  2042.   if rsCStyle in fRange then
    2043. 

  2043.     CStyleCommentProc
    2044. 

  2044.   else
    2045. 

  2045.     FProcTable[FLine[Run]]();
    2046. 

  2046. end;
    2047. 

  2047. 

  2048. function TSynCssSyn.GetDefaultAttribute(Index: integer): TSynHighlighterAttributes;
    2049. 

  2049. begin
    2050. 

  2050.   case Index of
    2051. 

  2051.     SYN_ATTR_COMMENT   : Result := FCommentAttri;
    2052. 

  2052.     SYN_ATTR_IDENTIFIER: Result := FIdentifierAttri;
    2053. 

  2053.     SYN_ATTR_KEYWORD   : Result := FKeyAttri;
    2054. 

  2054.     SYN_ATTR_STRING    : Result := FStringAttri;
    2055. 

  2055.     SYN_ATTR_WHITESPACE: Result := FSpaceAttri;
    2056. 

  2056.     SYN_ATTR_SYMBOL    : Result := FSymbolAttri;
    2057. 

  2057.     SYN_ATTR_NUMBER    : Result := fNumberAttri;
    2058. 

  2058.   else
    2059. 

  2059.     Result := nil;
    2060. 

  2060.   end;
    2061. 

  2061. end;
    2062. 

  2062. 

  2063. function TSynCssSyn.GetEol: Boolean;
    2064. 

  2064. begin
    2065. 

  2065.   Result := (FTokenID = tkNull);
    2066. 

  2066. end;
    2067. 

  2067. 

  2068. function TSynCssSyn.GetRange: Pointer;
    2069. 

  2069. begin
    2070. 

  2070.   Result := {%H-}Pointer(Integer(fRange));
    2071. 

  2071. end;
    2072. 

  2072. 

  2073. function TSynCssSyn.GetToken: string;
    2074. 

  2074. var
    2075. 

  2075.   Len: LongInt;
    2076. 

  2076. begin
    2077. 

  2077.   Result := '';
    2078. 

  2078.   Len := Run - FTokenPos;
    2079. 

  2079.   SetString(Result, (FLine + FTokenPos), Len);
    2080. 

  2080. end;
    2081. 

  2081. 

  2082. procedure TSynCssSyn.GetTokenEx(out TokenStart: PChar; out TokenLength: integer);
    2083. 

  2083. begin
    2084. 

  2084.   TokenLength:=Run-fTokenPos;
    2085. 

  2085.   TokenStart:=FLine + fTokenPos;
    2086. 

  2086. end;
    2087. 

  2087. 

  2088. function TSynCssSyn.GetTokenID: TtkTokenKind;
    2089. 

  2089. begin
    2090. 

  2090.   Result := FTokenId;
    2091. 

  2091. end;
    2092. 

  2092. 

  2093. function TSynCssSyn.GetTokenAttribute: TSynHighlighterAttributes;
    2094. 

  2094. begin
    2095. 

  2095.   case GetTokenID of
    2096. 

  2096.     tkComment   : Result := FCommentAttri;
    2097. 

  2097.     tkIdentifier: Result := FIdentifierAttri;
    2098. 

  2098.     tkKey       : Result := FKeyAttri;
    2099. 

  2099.     tkNumber    : Result := FNumberAttri;
    2100. 

  2100.     tkSpace     : Result := FSpaceAttri;
    2101. 

  2101.     tkString    : Result := FStringAttri;
    2102. 

  2102.     tkSymbol    : Result := FSymbolAttri;
    2103. 

  2103.     tkMeasurementUnit: Result := fMeasurementUnitAttri;
    2104. 

  2104.     tkSelector  : Result := fSelectorAttri;
    2105. 

  2105.     tkUnknown   : Result := FIdentifierAttri;
    2106. 

  2106.   else
    2107. 

  2107.     Result := nil;
    2108. 

  2108.   end;
    2109. 

  2109. end;
    2110. 

  2110. 

  2111. function TSynCssSyn.GetTokenKind: integer;
    2112. 

  2112. begin
    2113. 

  2113.   Result := Ord(fTokenId);
    2114. 

  2114. end;
    2115. 

  2115. 

  2116. function TSynCssSyn.GetTokenPos: Integer;
    2117. 

  2117. begin
    2118. 

  2118.   Result := FTokenPos;
    2119. 

  2119. end;
    2120. 

  2120. 

  2121. procedure TSynCssSyn.ReSetRange;
    2122. 

  2122. begin
    2123. 

  2123.   FRange := [];
    2124. 

  2124. end;
    2125. 

  2125. 

  2126. procedure TSynCssSyn.SetRange(Value: Pointer);
    2127. 

  2127. begin
    2128. 

  2128.   FRange := TRangeStates({%H-}Cardinal(Value));
    2129. 

  2129. end;
    2130. 

  2130. 

  2131. function TSynCssSyn.GetIdentChars: TSynIdentChars;
    2132. 

  2132. begin
    2133. 

  2133.   Result := TSynValidStringChars + ['-'];
    2134. 

  2134. end;
    2135. 

  2135. 

  2136. class function TSynCssSyn.GetLanguageName: string;
    2137. 

  2137. begin
    2138. 

  2138.   Result := SYNS_LangCSS;
    2139. 

  2139. end;
    2140. 

  2140. 

  2141. function TSynCssSyn.GetSampleSource: String;
    2142. 

  2142. begin
    2143. 

  2143.   Result := '/* Syntax highlighting */'#13#10 +
    2144. 

  2144.     'body'#13#10 +
    2145. 

  2145.     '{'#13#10 +
    2146. 

  2146.     '  font-family: "Arial";'#13#10 +
    2147. 

  2147.     '  font-size: 12pt;'#13#10 +
    2148. 

  2148.     '}';
    2149. 

  2149. end;
    2150. 

  2150. 

  2151. function TSynCssSyn.KeyHash2(ToHash: PChar): Integer;
    2152. 

  2152. begin
    2153. 

  2153.   Result := KeyHash(ToHash);
    2154. 

  2154. end;
    2155. 

  2155. 

  2156. 

  2157. initialization
    2158. 

  2158.   MakeIdentTable;
    2159. 

  2159.   RegisterPlaceableHighlighter(TSynCssSyn);
    2160. 

  2160. 

  2161. end.
    2162. 

  2162.