diff --git a/.gitattributes b/.gitattributes index 54543554b4..17bc0eddbb 100644 --- a/.gitattributes +++ b/.gitattributes @@ -81,6 +81,7 @@ components/synedit/synedittypes.pp svneol=native#text/pascal components/synedit/synexporthtml.pas svneol=native#text/pascal components/synedit/synhighlightercpp.pp svneol=native#text/pascal components/synedit/synhighlighterhtml.pp svneol=native#text/pascal +components/synedit/synhighlighterjava.pas svneol=native#text/pascal components/synedit/synhighlighterlfm.pas svneol=native#text/pascal components/synedit/synhighlightermulti.pas svneol=native#text/pascal components/synedit/synhighlighterpas.pp svneol=native#text/pascal diff --git a/components/codetools/basiccodetools.pas b/components/codetools/basiccodetools.pas index 5488b0c6e2..0ce8e2d679 100644 --- a/components/codetools/basiccodetools.pas +++ b/components/codetools/basiccodetools.pas @@ -1301,7 +1301,7 @@ begin i:=1; LastLineEndPos:=0; Result:=0; - while i #64) and (I < #91) then + mHashTable[I] := Ord(I) - 64 + else + if (I > #96) then + mHashTable[I] := Ord(I) - 95; + end + else + mHashTable[I] := 0; + end; +end; + +procedure TSynJavaSyn.InitIdent; +var + I: Integer; +begin + for I := 0 to 172 do + Case I of + 17: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func17; + 21: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func21; + 32: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func32; + 34: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func34; + 40: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func40; + 42: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func42; + 45: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func45; + 46: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func46; + 47: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func47; + 48: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func48; + 51: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func51; + 52: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func52; + 54: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func54; + 56: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func56; + 59: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func59; + 60: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func60; + 61: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func61; + 62: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func62; + 63: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func63; + 65: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func65; + 66: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func66; + 68: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func68; + 69: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func69; + 71: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func71; + 76: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func76; + 77: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func77; + 78: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func78; + 84: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func84; + 85: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func85; + 86: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func86; + 88: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func88; + 89: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func89; + 90: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func90; + 92: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func92; + 97: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func97; + 98: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func98; + 102: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func102; + 104: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func104; + 109: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func109; + 115: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func115; + 116: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func116; + 119: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func119; + 129: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func129; + 136: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func136; + 172: fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}Func172; + else fIdentFuncTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}AltFunc; + end; +end; + +function TSynJavaSyn.KeyHash(ToHash: PChar): Integer; +begin + Result := 0; + while (ToHash^ in ['_', '$', '0'..'9', 'a'..'z', 'A'..'Z']) or + (ToHash^ in TSynSpecialChars) do + begin + inc(Result, mHashTable[ToHash^]); + inc(ToHash); + end; + fStringLen := ToHash - fToIdent; +end; { KeyHash } + +function TSynJavaSyn.KeyComp(const aKey: String): Boolean; +var + I: Integer; + Temp: PChar; +begin + Temp := FToIdent; + if Length(aKey) = fStringLen then + begin + Result := True; + for i := 1 to fStringLen do + begin + if Temp^ <> aKey[i] then + begin + Result := False; + break; + end; + inc(Temp); + end; + end else Result := False; +end; { KeyComp } + +function TSynJavaSyn.Func17: TtkTokenKind; +begin + if KeyComp('if') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func21: TtkTokenKind; +begin + if KeyComp('do') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func32: TtkTokenKind; +begin + if KeyComp('case') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func34: TtkTokenKind; +begin + if KeyComp('char') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func40: TtkTokenKind; +begin + if KeyComp('catch') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func42: TtkTokenKind; +begin + if KeyComp('for') then Result := tkKey else + if KeyComp('break') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func45: TtkTokenKind; +begin + if KeyComp('else') then Result := tkKey else + if KeyComp('new') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func46: TtkTokenKind; +begin + if KeyComp('int') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func47: TtkTokenKind; +begin + if KeyComp('final') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func48: TtkTokenKind; +begin + if KeyComp('false') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func51: TtkTokenKind; +begin + if KeyComp('package') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func52: TtkTokenKind; +begin + if KeyComp('long') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func54: TtkTokenKind; +begin + if KeyComp('void') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func56: TtkTokenKind; +begin + if KeyComp('byte') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func59: TtkTokenKind; +begin + if KeyComp('class') then Result := tkKey else + if KeyComp('float') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func60: TtkTokenKind; +begin + if KeyComp('this') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func61: TtkTokenKind; +begin + if KeyComp('goto') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func62: TtkTokenKind; +begin + if KeyComp('while') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func63: TtkTokenKind; +begin + if KeyComp('null') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func65: TtkTokenKind; +begin + if KeyComp('double') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func66: TtkTokenKind; +begin + if KeyComp('try') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func68: TtkTokenKind; +begin + if KeyComp('true') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func69: TtkTokenKind; +begin + if KeyComp('public') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func71: TtkTokenKind; +begin + if KeyComp('boolean') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func76: TtkTokenKind; +begin + if KeyComp('default') then Result := tkKey else + if KeyComp('const') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func77: TtkTokenKind; +begin + if KeyComp('native') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func78: TtkTokenKind; +begin + if KeyComp('static') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func84: TtkTokenKind; +begin + if KeyComp('super') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func85: TtkTokenKind; +begin + if KeyComp('short') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func86: TtkTokenKind; +begin + if KeyComp('finally') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func88: TtkTokenKind; +begin + if KeyComp('switch') then Result := tkKey else + if KeyComp('assert') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func89: TtkTokenKind; +begin + if KeyComp('throw') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func90: TtkTokenKind; +begin + if KeyComp('interface') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func92: TtkTokenKind; +begin + if KeyComp('abstract') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func97: TtkTokenKind; +begin + if KeyComp('import') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func98: TtkTokenKind; +begin + if KeyComp('extends') then Result := tkKey else + if KeyComp('private') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func102: TtkTokenKind; +begin + if KeyComp('return') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func104: TtkTokenKind; +begin + if KeyComp('volatile') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func109: TtkTokenKind; +begin + if KeyComp('continue') then Result := tkKey else + if KeyComp('throws') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func115: TtkTokenKind; +begin + if KeyComp('protected') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func116: TtkTokenKind; +begin + if KeyComp('instanceof') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func119: TtkTokenKind; +begin + if KeyComp('strictfp') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func129: TtkTokenKind; +begin + if KeyComp('transient') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func136: TtkTokenKind; +begin + if KeyComp('implements') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.Func172: TtkTokenKind; +begin + if KeyComp('synchronized') then Result := tkKey else Result := tkIdentifier; +end; + +function TSynJavaSyn.AltFunc: TtkTokenKind; +begin + Result := tkIdentifier; +end; + +function TSynJavaSyn.IdentKind(MayBe: PChar): TtkTokenKind; +var + HashKey: Integer; +begin + fToIdent := MayBe; + HashKey := KeyHash(MayBe); + if HashKey < 173 then + Result := fIdentFuncTable[HashKey]() + else + Result := tkIdentifier; +end; + +procedure TSynJavaSyn.MakeMethodTables; +var + I: Char; +begin + for I := #0 to #255 do + case I of + '&': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}AndSymbolProc; + #39: fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}AsciiCharProc; + '@': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}AtSymbolProc; + '}': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}BraceCloseProc; + '{': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}BraceOpenProc; + #13: fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}CRProc; + ':': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}ColonProc; + ',': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}CommaProc; + '=': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}EqualProc; + '>': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}GreaterProc; + 'A'..'Z', 'a'..'z', '_', '$': + fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}IdentProc; + #10: fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}LFProc; + '<': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}LowerProc; + '-': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}MinusProc; + '*': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}MultiplyProc; + '!': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}NotSymbolProc; + #0: fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}NullProc; + '0'..'9': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}NumberProc; + '|': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}OrSymbolProc; + '+': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}PlusProc; + '.': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}PointProc; + '#': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}PoundProc; + '?': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}QuestionProc; + '%': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}RemainderSymbolProc; + ')': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}RoundCloseProc; + '(': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}RoundOpenProc; + ';': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}SemiColonProc; + '/': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}SlashProc; + #1..#9, #11, #12, #14..#32: + fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}SpaceProc; + ']': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}SquareCloseProc; + '[': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}SquareOpenProc; + #34: fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}StringProc; + '~': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}TildeProc; + '^': fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}XOrSymbolProc; + else + if (I in TSynSpecialChars) then + fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}IdentProc + else + fProcTable[I] := {$IFDEF SYN_LAZARUS}@{$ENDIF}UnknownProc; + end; +end; + +constructor TSynJavaSyn.Create(AOwner: TComponent); +begin + inherited Create(AOwner); + fCommentAttri := TSynHighlighterAttributes.Create(SYNS_AttrComment); + fCommentAttri.Style := [fsItalic]; + AddAttribute(fCommentAttri); + fDocumentAttri := TSynHighlighterAttributes.Create(SYNS_AttrDocumentation); + fDocumentAttri.Style := [fsItalic]; + AddAttribute(fDocumentAttri); + fIdentifierAttri := TSynHighlighterAttributes.Create(SYNS_AttrIdentifier); + AddAttribute(fIdentifierAttri); + fInvalidAttri := TSynHighlighterAttributes.Create(SYNS_AttrInvalidSymbol); + AddAttribute(fInvalidAttri); + fKeyAttri := TSynHighlighterAttributes.Create(SYNS_AttrReservedWord); + fKeyAttri.Style := [fsBold]; + AddAttribute(fKeyAttri); + fNumberAttri := TSynHighlighterAttributes.Create(SYNS_AttrNumber); + AddAttribute(fNumberAttri); + fSpaceAttri := TSynHighlighterAttributes.Create(SYNS_AttrSpace); + fSpaceAttri.Foreground := clWindow; + AddAttribute(fSpaceAttri); + fStringAttri := TSynHighlighterAttributes.Create(SYNS_AttrString); + AddAttribute(fStringAttri); + fSymbolAttri := TSynHighlighterAttributes.Create(SYNS_AttrSymbol); + AddAttribute(fSymbolAttri); + fRange := rsUnknown; + SetAttributesOnChange({$IFDEF SYN_LAZARUS}@{$ENDIF}DefHighlightChange); + + InitIdent; + MakeMethodTables; + fDefaultFilter := SYNS_FilterJava; +end; { Create } + +procedure TSynJavaSyn.SetLine({$IFDEF FPC}const {$ENDIF}NewValue: String; + LineNumber:Integer); +begin + fLine := PChar(NewValue); + Run := 0; + fEol := False; + fLineNumber := LineNumber; + Next; +end; { SetLine } + +procedure TSynJavaSyn.CommentProc; +begin + if fRange = rsComment then + fTokenID := tkComment + else + fTokenID := tkDocument; + case FLine[Run] of + #0: + begin + NullProc; + exit; + end; + #10: + begin + LFProc; + exit; + end; + #13: + begin + CRProc; + exit; + end; + end; + + while FLine[Run] <> #0 do + case FLine[Run] of + '*': + if fLine[Run + 1] = '/' then + begin + inc(Run, 2); + fRange := rsUnknown; + break; + end + else inc(Run); + #10: break; + #13: break; + else inc(Run); + end; +end; + +procedure TSynJavaSyn.AndSymbolProc; +begin + case FLine[Run + 1] of + '=': {and assign} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkAndAssign; + end; + '&': {conditional and} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkCondAnd; + end; + else {and} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkAnd; + end; + end; +end; + +procedure TSynJavaSyn.AsciiCharProc; +begin + fTokenID := tkString; + repeat + case FLine[Run] of + #0, #10, #13: break; + #92: Inc(Run); // backslash, if we have an escaped single character, skip to the next + end; + if FLine[Run] <> #0 then inc(Run); //Add check here to prevent overrun from backslash being last char + until FLine[Run] = #39; + if FLine[Run] <> #0 then inc(Run); +end; + +procedure TSynJavaSyn.AtSymbolProc; +begin + fTokenID := tkInvalid; + inc(Run); +end; + +procedure TSynJavaSyn.BraceCloseProc; +begin + inc(Run); + fTokenId := tkSymbol; + FExtTokenID := xtkBraceClose; +end; + +procedure TSynJavaSyn.BraceOpenProc; +begin + inc(Run); + fTokenId := tkSymbol; + FExtTokenID := xtkBraceOpen; +end; + +procedure TSynJavaSyn.CRProc; +begin + fTokenID := tkSpace; + Case FLine[Run + 1] of + #10: inc(Run, 2); + else inc(Run); + end; +end; + +procedure TSynJavaSyn.ColonProc; +begin + inc(Run); {colon - conditional} + fTokenID := tkSymbol; + FExtTokenID := xtkColon; +end; + +procedure TSynJavaSyn.CommaProc; +begin + inc(Run); + fTokenID := tkSymbol; //tkInvalid; //DDH Addition from Eden Kirin + fExtTokenID := xtkComma; //GBN 13/12/2001 +end; + +procedure TSynJavaSyn.EqualProc; +begin + case FLine[Run + 1] of + '=': {logical equal} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkLogEqual; + end; + else {assign} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkAssign; + end; + end; +end; + +procedure TSynJavaSyn.GreaterProc; +begin + Case FLine[Run + 1] of + '=': {greater than or equal to} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkGreaterThanEqual; + end; + '>': + begin + Case FLine[Run + 2] of + '=': {shift right assign} + begin + inc(Run, 3); + FExtTokenID := xtkShiftRightAssign; + end; + '>': + if FLine[Run + 3] = '=' then + begin + inc(Run, 4); {unsigned shift right assign} + FExtTokenID := xtkUnsignShiftRightAssign; + end + else + begin + inc(Run, 3); {unsigned shift right} + FExtTokenID := xtkUnsignShiftRight; + end; + else {shift right} + begin + inc(Run, 2); + FExtTokenID := xtkShiftRight; + end; + end; + fTokenID := tkSymbol; + end; + else {greater than} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkGreaterThan; + end; + end; +end; + +procedure TSynJavaSyn.IdentProc; +begin + fTokenID := IdentKind((fLine + Run)); + inc(Run, fStringLen); + while Identifiers[fLine[Run]] do inc(Run); +end; + +procedure TSynJavaSyn.LFProc; +begin + fTokenID := tkSpace; + inc(Run); +end; + +procedure TSynJavaSyn.LowerProc; +begin + case FLine[Run + 1] of + '=': {less than or equal to} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkLessThanEqual; + end; + '<': + begin + if FLine[Run + 2] = '=' then {shift left assign} + begin + inc(Run, 3); + FExtTokenID := xtkShiftLeftAssign; + end + else {shift left} + begin + inc(Run, 2); + FExtTokenID := xtkShiftLeft; + end; + fTokenID := tkSymbol; + end; + else {less than} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkLessThan; + end; + end; +end; + +procedure TSynJavaSyn.MinusProc; +begin + case FLine[Run + 1] of + '=': {subtract assign} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkSubtractAssign; + end; + '-': {decrement} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkDecrement; + end; + else {subtract} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkSubtract; + end; + end; +end; + +procedure TSynJavaSyn.MultiplyProc; +begin + case FLine[Run + 1] of + '=': {multiply assign} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkMultiplyAssign; + end; + else {multiply} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkMultiply; + end; + end; +end; + +procedure TSynJavaSyn.NotSymbolProc; +begin + case FLine[Run + 1] of + '=': {not equal} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkNotEqual; + end; + else {logical complement} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkLogComplement; + end; + end; +end; + +procedure TSynJavaSyn.NullProc; +begin + fTokenID := tkNull; + fEol := True; +end; + +procedure TSynJavaSyn.NumberProc; +begin + inc(Run); + fTokenID := tkNumber; + while FLine[Run] in + ['0'..'9', '.', '-', 'l', 'L', 'x', 'X', 'A'..'F', 'a'..'f'] do + begin + case FLine[Run] of + '.': + if FLine[Run + 1] = '.' then break; + end; + inc(Run); + end; +end; + +procedure TSynJavaSyn.OrSymbolProc; +begin + case FLine[Run + 1] of + '=': {inclusive or assign} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkIncOrAssign; + end; + '|': {conditional or} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkCondOr; + end; + else {inclusive or} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkIncOr; + end; + end; +end; + +procedure TSynJavaSyn.PlusProc; +begin + case FLine[Run + 1] of + '=': {add assign} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkAddAssign; + end; + '+': {increment} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkIncrement; + end; + else {add} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkAdd; + end; + end; +end; + +procedure TSynJavaSyn.PointProc; +begin + inc(Run); {point} + if FLine[Run] in ['0'..'9'] then + begin + NumberProc; + Exit; + end; + fTokenID := tkSymbol; + FExtTokenID := xtkPoint; +end; + +procedure TSynJavaSyn.PoundProc; +begin + inc(Run); + fTokenID := tkInvalid; +end; + +procedure TSynJavaSyn.QuestionProc; +begin + fTokenID := tkSymbol; {question mark - conditional} + FExtTokenID := xtkQuestion; + inc(Run); +end; + +procedure TSynJavaSyn.RemainderSymbolProc; +begin + case FLine[Run + 1] of + '=': {remainder assign} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkRemainderAssign; + end; + else {remainder} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkRemainder; + end; + end; +end; + +procedure TSynJavaSyn.RoundCloseProc; +begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkRoundClose; + dec(FRoundCount); +end; + +procedure TSynJavaSyn.RoundOpenProc; +begin + inc(Run); + FTokenID := tkSymbol; + FExtTokenID := xtkRoundOpen; + inc(FRoundCount); +end; + +procedure TSynJavaSyn.SemiColonProc; +begin + inc(Run); {semicolon} + fTokenID := tkSymbol; + FExtTokenID := xtkSemiColon; +end; + +procedure TSynJavaSyn.SlashProc; +begin + case FLine[Run + 1] of + '/': {c++ style comments} + begin + inc(Run, 2); + fTokenID := tkComment; + while FLine[Run] <> #0 do + begin + case FLine[Run] of + #10, #13: break; + end; + inc(Run); + end; + end; + '*': + begin + if fLine[Run+2] = '*' then {documentation comment} + begin + fRange := rsDocument; + fTokenID := tkDocument; + inc(Run); + end + else {c style comment} + begin + fRange := rsComment; + fTokenID := tkComment; + end; + + inc(Run,2); + while fLine[Run] <> #0 do + case fLine[Run] of + '*': + if fLine[Run + 1] = '/' then + begin + inc(Run, 2); + fRange := rsUnknown; + break; + end else inc(Run); + #10: break; + #13: break; + else + inc(Run); + end; + end; + '=': {division assign} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkDivideAssign; + end; + else {division} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkDivide; + end; + end; +end; + +procedure TSynJavaSyn.SpaceProc; +begin + inc(Run); + fTokenID := tkSpace; + while FLine[Run] in [#1..#9, #11, #12, #14..#32] do inc(Run); +end; + +procedure TSynJavaSyn.SquareCloseProc; +begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkSquareClose; + dec(FSquareCount); +end; + +procedure TSynJavaSyn.SquareOpenProc; +begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkSquareOpen; + inc(FSquareCount); +end; + +procedure TSynJavaSyn.StringProc; +begin + fTokenID := tkString; + if (FLine[Run + 1] = #34) and (FLine[Run + 2] = #34) then inc(Run, 2); + repeat + case FLine[Run] of + #0, #10, #13: break; + #92: Inc(Run); // Backslash, if we have an escaped charcter it can be skipped + end; + if FLine[Run] <> #0 then inc(Run); //Add check here to prevent overrun from backslash being last char + until FLine[Run] = #34; + if FLine[Run] <> #0 then inc(Run); +end; + +procedure TSynJavaSyn.TildeProc; +begin + inc(Run); {bitwise complement} + fTokenId := tkSymbol; + FExtTokenID := xtkBitComplement; +end; + +procedure TSynJavaSyn.XOrSymbolProc; +begin + Case FLine[Run + 1] of + '=': {xor assign} + begin + inc(Run, 2); + fTokenID := tkSymbol; + FExtTokenID := xtkXorAssign; + end; + else {xor} + begin + inc(Run); + fTokenID := tkSymbol; + FExtTokenID := xtkXor; + end; + end; +end; + +procedure TSynJavaSyn.UnknownProc; +begin +{$IFDEF SYN_MBCSSUPPORT} + if FLine[Run] in LeadBytes then + Inc(Run,2) + else +{$ENDIF} + inc(Run); + fTokenID := tkUnknown; +end; + +procedure TSynJavaSyn.Next; +begin + fTokenPos := Run; + Case fRange of + rsComment: CommentProc; + rsDocument: CommentProc; + else + begin + fRange := rsUnknown; + fProcTable[fLine[Run]]; + end; + end; +end; + +function TSynJavaSyn.GetDefaultAttribute(Index: integer): TSynHighlighterAttributes; +begin + case Index of + SYN_ATTR_COMMENT: Result := fCommentAttri; + SYN_ATTR_IDENTIFIER: Result := fIdentifierAttri; + SYN_ATTR_KEYWORD: Result := fKeyAttri; + SYN_ATTR_STRING: Result := fStringAttri; + SYN_ATTR_WHITESPACE: Result := fSpaceAttri; + SYN_ATTR_SYMBOL: Result := fSymbolAttri; + else Result := nil; + end; +end; + +function TSynJavaSyn.GetEol: Boolean; +begin + Result := fTokenID = tkNull; +end; + +function TSynJavaSyn.GetRange: Pointer; +begin + Result := Pointer(fRange); +end; + +procedure TSynJavaSyn.ReSetRange; +begin + fRange := rsUnknown; +end; + +procedure TSynJavaSyn.SetRange(Value: Pointer); +begin + fRange := TRangeState(Value); +end; + +function TSynJavaSyn.GetToken: String; +var + Len: LongInt; +begin + Len := Run - fTokenPos; + SetString(Result, (FLine + fTokenPos), Len); +end; + +{$IFDEF SYN_LAZARUS} +procedure TSynJavaSyn.GetTokenEx(var TokenStart: PChar; var TokenLength: integer + ); +begin + TokenLength:=Run-fTokenPos; + TokenStart:=FLine + fTokenPos; +end; +{$ENDIF} + +function TSynJavaSyn.GetTokenID: TtkTokenKind; +begin + Result := fTokenId; +end; + +function TSynJavaSyn.GetExtTokenID: TxtkTokenKind; +begin + Result := FExtTokenID; +end; + +function TSynJavaSyn.GetTokenAttribute: TSynHighlighterAttributes; +begin + case fTokenID of + tkComment: Result := fCommentAttri; + tkDocument: Result := fDocumentAttri; + tkIdentifier: Result := fIdentifierAttri; + tkInvalid: Result := fInvalidAttri; + tkKey: Result := fKeyAttri; + tkNumber: Result := fNumberAttri; + tkSpace: Result := fSpaceAttri; + tkString: Result := fStringAttri; + tkSymbol: Result := fSymbolAttri; + tkUnknown: Result := fInvalidAttri; + else Result := nil; + end; +end; + +function TSynJavaSyn.GetTokenKind: integer; +begin + Result := Ord(fTokenId); +end; + +function TSynJavaSyn.GetTokenPos: Integer; +begin + Result := fTokenPos; +end; + +function TSynJavaSyn.GetIdentChars: TSynIdentChars; +begin + Result := ['_', '$', '0'..'9', 'a'..'z', 'A'..'Z'] + TSynSpecialChars; +end; + +{$IFNDEF SYN_CPPB_1} class {$ENDIF} //mh 2000-07-14 +function TSynJavaSyn.GetLanguageName: string; +begin + Result := SYNS_LangJava; +end; + +function TSynJavaSyn.GetSampleSource: string; +begin + Result := '/* Java syntax highlighting */'#13#10 + + 'import java.util.*;'#13#10 + + #13#10 + + '/** Example class */'#13#10 + + 'public class Sample {'#13#10 + + ' public static void main(String[] args) {'#13#10 + + ' int i = 0;'#13#10 + + ' for(i = 0; i < 10; i++)'#13#10 + + ' System.out.println("Hello world");'#13#10 + + ' }'#13#10 + + '}'; +end; + +initialization + MakeIdentTable; +{$IFNDEF SYN_CPPB_1} //mh 2000-07-14 + RegisterPlaceableHighlighter(TSynJavaSyn); +{$ENDIF} +end. + diff --git a/ide/editoroptions.pp b/ide/editoroptions.pp index 423704d372..957fbb3db5 100644 --- a/ide/editoroptions.pp +++ b/ide/editoroptions.pp @@ -47,7 +47,7 @@ uses {$ifdef NEW_EDITOR_SYNEDIT} SynEdit, SynEditHighlighter, SynEditAutoComplete, SynEditKeyCmds, SynHighlighterPas, SynHighlighterHTML, SynHighlighterCPP, SynHighlighterXML, - SynHighlighterLFM, SynHighlighterPerl, + SynHighlighterLFM, SynHighlighterPerl, SynHighlighterJava, {$else} mwCustomEdit, mwPasSyn, mwHighlighter, {$endif} @@ -70,7 +70,7 @@ type TLazSyntaxHighlighter = (lshNone, lshText, lshFreePascal, lshDelphi, lshLFM, lshXML, lshHTML, - lshCPP, lshPerl); + lshCPP, lshPerl, lshJava); TAdditionalHilightAttribute = (ahaNone, ahaTextBlock, ahaExecutionPoint, ahaEnabledBreakpoint, ahaDisabledBreakpoint, ahaInvalidBreakpoint, @@ -90,7 +90,7 @@ const LazSyntaxHighlighterClasses: array[TLazSyntaxHighlighter] of TCustomSynClass = ( nil, nil, TSynPasSyn, TSynPasSyn, TSynLFMSyn, TSynXMLSyn, TSynHTMLSyn, - TSynCPPSyn, TSynPerlSyn); + TSynCPPSyn, TSynPerlSyn, TSynJavaSyn); { Comments } @@ -104,7 +104,8 @@ const comtHtml, // lshXML comtHtml, // lshHTML comtCPP, // lshCPP - comtPerl // lshPerl + comtPerl, // lshPerl + comtCPP // lshJava ); const @@ -535,7 +536,8 @@ const 'XML', 'HTML', 'C++', - 'Perl' + 'Perl', + 'Java' ); var @@ -560,7 +562,7 @@ const CompatibleLazSyntaxHilighter: array[TLazSyntaxHighlighter] of TLazSyntaxHighlighter= ( lshNone, lshText, lshFreePascal, lshFreePascal, lshLFM, lshXML, lshHTML, - lshCPP, lshPerl + lshCPP, lshPerl, lshJava ); DefaultColorScheme = 'Default'; @@ -944,6 +946,42 @@ begin end; end; Add(NewInfo); + + // create info for Perl + NewInfo:=TEditOptLanguageInfo.Create; + with NewInfo do begin + TheType:=CompatibleLazSyntaxHilighter[lshJava]; + DefaultCommentType:=DefaultCommentTypes[TheType]; + SynClass:=LazSyntaxHighlighterClasses[TheType]; + FileExtensions:='java'; + SampleSource:= + '/* Java syntax highlighting */'#13#10 + + 'import java.util.*;'#13#10 + + #13#10 + + '/** Example class */'#13#10 + + 'public class Sample {'#13#10 + + ' public static void main(String[] args) {'#13#10 + + ' int i = 0;'#13#10 + + ' for(i = 0; i < 10; i++)'#13#10 + + ' System.out.println("Hello world");'#13#10 + + ' }'#13#10 + + '}'#13#10 + + '/* Text Block */'#13#10 + + #13#10; + AddAttrSampleLines[ahaTextBlock]:=12; + MappedAttributes:=TStringList.Create; + with MappedAttributes do begin + Add('Comment=Comment'); + Add('Documentation=Comment'); + Add('Identifier=Identifier'); + Add('Reserved_word=Reserved_word'); + Add('Number=Number'); + Add('Space=Space'); + Add('String=String'); + Add('Symbol=Symbol'); + end; + end; + Add(NewInfo); end; destructor TEditOptLangList.Destroy;