[BUG] kleine foutjes in syntax highlighter

[Daos]

Er zitten 2 kleine foutjes in syntax highlighter.

Bij java: Floating point getal zonder punt erin wordt niet goed herkend.

Java:

1e-10
1.0e-10

Bij vb: "False" wordt niet herkend.

Visual Basic:

True
False
If Null Aap Noot Mies ByRef

[crisp]

*noted*

[moto-moi]

2e bug gefixed in locale code, eerste bug mag crisp ff een fix voor bedenken en daarna zal ik de hele zooi weer eens updaten.

[crisp]

Het matchen van nummers is inderdaad niet helemaal 100 in de java lexer; dit zijn de huidige rules:

code:

dig         [0-9]
intpostfix  [Ll]
num1        [\-+]?[1-9]{dig}*({intpostfix}|(\.([eE][\-+]?{dig}+)?[fF]?))?
num2        [\-+]?([1-9]{dig}*)?\.{dig}+([eE][\-+]?{dig}+)?[fF]?
hexnum      [\-+]?0[xX]{hexdig}+{intpostfix}?
octnum      [\-+]?0[0-7]*{intpostfix}?
number      {num1}|{num2}|{hexnum}|{octnum}

Je ziet hier al dat 1e-10 niet matched. Integer 0 wordt gematched als octaal, en 0.0 in feite als een octaal nummer ( 0 ) gevolgd door een float ( .0 )
Dit lijkt mij al beter:

code:

dig         [0-9]
long        [Ll]
double      [Dd]
float       [Ff]
exp         [Ee]
int         [\-+]?([1-9]{dig}*|0)({long}|{exp}[\-+]?{dig}+)?
float       [\-+]?([1-9]{dig}*|0)?\.{dig}*({exp}[\-+]?{dig}+)?({double}|{float})?
hexnum      [\-+]?0[xX]{hexdig}+{long}?
octnum      [\-+]?0[0-7]*{long}?
number      {int}|{float}|{hexnum}|{octnum}

maar misschien kan iemand anders ook even kijken of dat wel volledig is

edit: mmz, ik vergeet dat 1F en 1e357D ook geldig zijn... morgen nog maar eens kijken

[ Voor 15% gewijzigd door crisp op 05-08-2005 00:44 ]

[Daos]

Zie http://java.sun.com/docs/...n/html/lexical.html#48272

[crisp]

Daos schreef op vrijdag 05 augustus 2005 @ 09:47:
Zie http://java.sun.com/docs/...n/html/lexical.html#48272

Ah thanks, ik zie dat ik HexadecimalFloatingPointLiteral en BinaryExponent dus ook mee moet nemen

[crisp]

dan kom ik hier op uit:

code:

dig         [0-9]
octdig      [0-7]
hexdig      [0-9A-Fa-f]
long        [Ll]
double      [Dd]
float       [Ff]
exp         [Ee]
binexp      [Pp]
int         [+-]?(0|[1-9]{dig}*)({long}|{exp}[+-]?{dig}+)?
float1      [+-]?(0|[1-9]{dig}*)?\.{dig}*({exp}[+-]?{dig}+)?({double}|{float})?
float2      [+-]?(0|[1-9]{dig}*)({exp}[+-]?{dig}+)?({double}|{float})
hexnum      [+-]?0[xX]{hexdig}+{long}?
hexfloat    [+-]?0[xX]({hexdig}+(\.{hexdig}*)?|\.{hexdig}+){binexp}[+-]?{dig}+({double}|{float})?
octnum      [+-]?0{octdig}+{long}?
number      {int}|{float1}|{float2}|{hexfloat}|{hexnum}|{octnum}

kan wellicht wel wat eenvoudiger geschreven worden nog...

[ Voor 5% gewijzigd door crisp op 05-08-2005 13:38 ]

[Daos]

Het beste waar ik op uit kom is:

code:

dig         [0-9]
octdig      [0-7]
hexdig      [0-9A-Fa-f]
long        [Ll]
double      [Dd]
float       [Ff]
exp         [Ee]
binexp      [Pp]

int         (0|[1-9]{dig}*){long}?
hexnum      0[xX]{hexdig}+{long}?
octnum      0{octdig}+{long}?

float1      {dig}+\.{dig}*({exp}[+-]?{dig}+)?({double}|{float})?
float2      \.{dig}+({exp}[+-]?{dig}+)?({double}|{float})?
float3      {dig}+{exp}[+-]?{dig}+({double}|{float})?
float4      {dig}+({exp}[+-]?{dig}+)?({double}|{float})
float       {float1}|{float2}|{float3}|{float4}
hexfloat1   0[xX]{hexdig}+\.?{binexp}[+-]?{dig}+({double}|{float})?
hexfloat2   0[xX]{hexdig}*\.{hexdig}+{binexp}[+-]?{dig}+({double}|{float})?
hexfloat    {hexfloat1}|{hexfloat2}

number      {int}|{float}|{hexfloat}|{hexnum}|{octnum}

[edit]
waarschijnlijk kan dit ook:

code:

float1      (({dig}+\.{dig}*)|(\.{dig}+))({exp}[+-]?{dig}+)?({double}|{float})?
float2      {dig}+(({exp}[+-]?{dig}+({double}|{float})?)|({double}|{float}))
float       {float1}|{float2}
hexfloat    0[xX](({hexdig}+\.?)|({hexdig}*\.{hexdig}+)){binexp}[+-]?{dig}+({double}|{float})?

[ Voor 24% gewijzigd door Daos op 05-08-2005 14:29 ]

[crisp]

In hoeverre wijkt die af van mijn opzet? oftewel zijn er situaties die in mijn opzet onterecht matchen, of juist niet matchen terwijl dat wel zou moeten?

je mist trouwens over het optionele signteken vooraan.

[Daos]

Sign staat niet in de specificaties. Het is waarschijnlijk een operator.

hexfloat is goed (sorry).

float:
.e5f mag niet en wordt wel herkend en 1e5 mag wel en wordt niet herkend.

[ Voor 16% gewijzigd door crisp op 05-08-2005 15:21 . Reden: oops, wrong button ]

[crisp]

1e5 matched wel (als int), .e5f is inderdaad niet correct en matched bij mij wel als float - will fix

sign is idd een operator.

edit:

code:

float1      [+-]?((0|[1-9]{dig}*)\.{dig}*|\.{dig}+)({exp}[+-]?{dig}+)?({double}|{float})?

zo matched .e5f enzo ook niet meer

[ Voor 50% gewijzigd door crisp op 05-08-2005 15:29 ]

[Daos]

Ik had niet bij int gekeken. Ik dacht dat daar alleen integers herkend werden.

Die getallen zijn nu goed volgens mij.


Verder nog:
Tegenwoordig is er ook een "assert" en "enum" in java.

Java:

        abstract    continue    for           new          switch
        assert      default     if            package      synchronized
        boolean     do          goto          private      this
        break       double      implements    protected    throw
        byte        else        import        public       throws
        case        enum        instanceof    return       transient
        catch       extends     int           short        try
        char        final       interface     static       void 
        class       finally     long          strictfp     volatile
        const       float       native        super        while      
        true        false       null

Sommige foute characters worden ook herkend:
[code=java]
char[] goed = {'a', '\n', '\112', '\32'};
char[] fout = {'\400', '\c', '\8', '\xff', 'aa', ''};
[/code]

Geldige identifiers

Java:

a123
_123
$123

[ Voor 18% gewijzigd door Daos op 05-08-2005 17:07 . Reden: Ik moet niet overdrijven ]

[crisp]

Daos schreef op vrijdag 05 augustus 2005 @ 16:31:
Ik had niet bij int gekeken. Ik dacht dat daar alleen integers herkend werden.

syntactisch was het makkelijker om dat daarbij te matchen, maar je hebt gelijk dat het strict genomen geen int is

Die getallen zijn nu goed volgens mij.

mooi, dan kan ik moto-moi daarmee spanken

Verder nog:
Tegenwoordig is er ook een "assert" en "enum" in java.

Java:

        abstract    continue    for           new          switch
        assert      default     if            package      synchronized
        boolean     do          goto          private      this
        break       double      implements    protected    throw
        byte        else        import        public       throws
        case        enum        instanceof    return       transient
        catch       extends     int           short        try
        char        final       interface     static       void 
        class       finally     long          strictfp     volatile
        const       float       native        super        while      
        true        false       null

Dat is makkelijk te fixen

Geldige identifiers

Java:

a123
_123
$123

dus identifiers met een dollar-sign gaan nog fout?
Het staat er nu zo in:

code:

ident       [A-Za-z_][0-9A-Za-z_$]*

maar zou dus denk ik zo moeten zijn:

code:

ident       [A-Za-z_$][0-9A-Za-z_$]*

[Daos]

crisp schreef op vrijdag 05 augustus 2005 @ 18:53:
[...]

dus identifiers met een dollar-sign gaan nog fout?
Het staat er nu zo in:

code:

ident       [A-Za-z_][0-9A-Za-z_$]*

maar zou dus denk ik zo moeten zijn:

code:

ident       [A-Za-z_$][0-9A-Za-z_$]*

Dat laatste is goed als je je beperkt tot de Ascii characters.

In java is veel meer toegestaan. Er zijn zelfs speciale functies gemaakt om te kijken of iets bruikbaar is in een identifier. (De tweede functie geeft naast 0-9A-Za-z_$ ook waar bij alle control characters )

Java:

public class Ident {
  public static void main(String[] args) {
    char end = 127; // ASCII

    //end = Character.MAX_VALUE; // voor als je wilt schrikken

    System.out.println("Identifier mag beginnen met:");
    for (char ch = 0; ch <= end; ch++)
      if (Character.isJavaIdentifierStart(ch))
        System.out.print("\'" + ch + "\' ");
    System.out.println();


    System.out.println("Identifier mag verder bestaan uit:");
    for (char ch = 0; ch <= end; ch++)
      if (Character.isJavaIdentifierPart(ch))
        System.out.print("\'" + ch + "\' ");
    System.out.println();
  }
}

[moto-moi]

Tino, doe eens je mail beloeren ?

[crisp]

Looks good to me

[moto-moi]

Java:

1e-10
1.0e-10

Visual Basic:

True
False
If Null Aap Noot Mies ByRef

Looks good to me too

Java:

        abstract    continue    for           new          switch
        assert      default     if            package      synchronized
        boolean     do          goto          private      this
        break       double      implements    protected    throw
        byte        else        import        public       throws
        case        enum        instanceof    return       transient
        catch       extends     int           short        try
        char        final       interface     static       void 
        class       finally     long          strictfp     volatile
        const       float       native        super        while      
        true        false       null

Gevalletje 'done' lijkt me
Daos, bedankt

[ Voor 76% gewijzigd door moto-moi op 09-08-2005 00:06 ]