After them all the text is highlighted as a string (red in my case). I found no solution but to remove String Chars = ' from WORDFILE.TXT
Any suggestion?
I have tried your example lines with the pascal wordfile from the download area with V10.10c and V11.10a+3. In both versions all 4 strings in the 4 lines are highlighted completely as strings. The embedded block comments {0} did not have any influence on the string highlighting.
Could you post your language definition line and the delimiters definition from your wordfile and colorize your example lines. Use the preview button before submit your post.
Best regards from an UC/UE/UES for Windows user from Austria
/L6"Delphi" Nocase Line Comment = // Block Comment On = { Block Comment On Alt = (* Block Comment Off = } Block Comment Off Alt = *) Escape Char = · String Chars = ' File Extensions = pas dpr dpk
/Delimiters = #$&()*+,-./;<>@[]^{}tab'
/Function String = "%^{procedure^}^{function^}"
/Indent Strings = "begin" "const" "then" "else" "private" "protected" "public" "published" "type" "record" "var" "asm"
/Unindent Strings = "end" "until"
/Open Brace Strings = "{" "(" "["
/Close Brace Strings = "}" ")" "]"
/Open Fold Strings = "begin"
/Close Fold Strings = "end"
/C1"Keywords"
array as asm
begin
case class const constructor
destructor dispinterface do downto
else end except
file finalization finally for function
goto
helper
if implementation in inherited initialization inline interface is
label library
nil
object of on out
packed procedure program property
raise record repeat resourcestring
set string
then threadvar to try type
unit until uses
var
while with
/C2"Directives"
add at absolute abstract assembler automated
cdecl contains
default dispid dynamic
exports external
far final forward
implements index
message
near nodefault
overload override
package pascal private protected public published
read readonly register reintroduce remove requires resident
safecall sealed static stdcall stored strict
virtual
write writeonly
/C3"Operators"
and as
div
in is
mod
not
or
shl shr
xor
/C4"Special symbols"
*
+
-
/
< <= <>
=
> >=
@
#
$
&
(
(.
)
,
.
.)
..
:
:=
;
[
]
^
This is more complete sample of a file where the problem appears. I use red for strings and I have colorized in red what appears in that color in my editor
unit Commons.AbstractFactory;
interface
uses
System.Collections;
type
TAbstractFactoryKey = class abstract (TObject)
protected
function StringKey: string; virtual; abstract;
end;
TAbstractFactory = class (TObject)
public type
EAbstractFactory = class(Exception);
EMissingFactory = class(EAbstractFactory);
EFactoryWrongClass = class(EAbstractFactory);
strict private
class var
FactoryClassList: HashTable;
strict private
&Class: TClass;
strict private
class function FactoryList: HashTable;
class constructor Create;
public
class function ClassFromKey(Key: string; RequiredClass: TClass): TClass; overload;
class function ClassFromKey(Key: TAbstractFactoryKey; RequiredClass: TClass): TClass; overload;
public
constructor Create(&Class: TClass); overload;
constructor Create(Key: string; &Class: TClass); overload;
constructor Create(Key: TAbstractFactoryKey; &Class: TClass); overload;
end;
{$region 'Esempio di derivazione'}{
// Data una classe TMyClass, origine di una gerarchia di classi, vogliamo una factory per esse.
// TMyClass deve avere un costruttore virtuale, non ci sono vincoli sulla sua lista di parametri.
// La factory deve derivare da TAbstractFactory e implementare una o ambedue le forme di Produce che,
// dopo il parametro Key, devono ripetere la lista di parametri del costruttore virtuale di TMyClass.
TMyClassFactory = class(TAbstractFactory)
public
class function Produce(Key: string; <create args list>): TMyClass; overload;
class function Produce(Key: TAbstractFactoryKey; <create args list>): TMyClass; overload;
end;
// Una volta definita la factory per ognuna delle classi T derivate da TMyClass occorre creare la factory
// corrispondente utilizzando nella initialization della unit uno dei constructor
// In questo caso la chiave per T e' il suo class name.
TMyClassFactory.Create(T);
// In questo caso la chiave per T e' 'Key for T'.
TMyClassFactory.Create('Key for T',T);
// In questo caso la chiave per T e' ottenuta dai valori passati al constructor della chiave.
TMyClassFactory.Create(TMyClassFactoryKey.Create(<key parameters>),T);
// Per una stessa classe e' anche possibile creare piu' factory con chiavi diverse.
// Per utilizzare la factory per creare una classe T derivata da TMyClass in base ad una chiave
// si usa una delle forme di Produce
O := TMyClassFactory.Produce(Key,<create args list>);
// dove Key e' una stringa (case insensitive) o una istanza di TMyClassFactoryKey.
}{$endregion}
{$region 'Utilizzo di TAbstractFactoryKey'}{
// Quando come chiave per la factory si voglia usare un insieme di informazioni invece di una
// semplice stringa e' conviente derivare TAbstractFactoryKey
TMyClassFactoryKey = class(TAbstractFactoryKey)
protected
function StringKey: string; override;
public
Info1: string;
.
.
constructor Create(Info1: string; ...);
end;
// La funzione StringKey deve combinare tutti i campi pubblici ottenendone una stringa (case insensitive)
// dipendente solo dal loro valore. Il constructor, opzionale, serve a inizializzare in una sola linea
// tutti i campi pubblici.
}{$endregion}
implementation
{ TAbstractFactory }
class function TAbstractFactory.FactoryList: HashTable;
begin
Result := FactoryClassList[TObject(Self)] as HashTable;
if not Assigned(Result) then begin
Result := HashTable.Create(CaseInsensitiveHashCodeProvider.Create,CaseInsensitiveComparer.Create);
FactoryClassList.Add(TObject(Self),Result);
end;
end;
class constructor TAbstractFactory.Create;
begin
FactoryClassList := HashTable.Create;
end;
class function TAbstractFactory.ClassFromKey(Key: TAbstractFactoryKey; RequiredClass: TClass): TClass;
begin
Result := ClassFromKey(Key.StringKey,RequiredClass);
end;
class function TAbstractFactory.ClassFromKey(Key: string; RequiredClass: TClass): TClass;
var
Factory: TAbstractFactory;
begin
Factory := TAbstractFactory(FactoryList[Key]);
if Assigned(Factory) then begin
Result := Factory.&Class;
if not Result.InheritsFrom(RequiredClass) then
raise EFactoryWrongClass.Create(System.string.Format('Factory for class {0} produces wrong class ({1})',[RequiredClass.ClassName,Result.ClassName]));
end
else
raise EMissingFactory.Create(System.string.Format('No factory found for key {0}',[Key])); end;
constructor TAbstractFactory.Create(&Class: TClass);
begin
Create(&Class.ClassName,&Class);
end;
constructor TAbstractFactory.Create(Key: TAbstractFactoryKey; &Class: TClass);
begin
Create(Key.StringKey,&Class);
end;
{$region 'Esempio di derivazione'}{
// Le Produce devono avere questa forma in cui compare il nome della classe base TMyClass,
// la dichiarazione della sua metaclasse TMyClassClass, e i parametri passati invariati al costruttore.
class function TMyClassFactory.Produce(Key: string; <create args list>): TMyClass;
type
TMyClassClass = class of TMyClass;
begin
Result := TMyClassClass(ClassFromKey(Key,TMyClass)).Create(<create args values>);
end;
class function TMyClassFactory.Produce(Key: TAbstractFactoryKey; <create args list>): TMyClass;
type
TMyClassClass = class of TMyClass;
begin
Result := TMyClassClass(ClassFromKey(Key,TMyClass)).Create(<create args values>);
end;
I think, you have found a bug in UE's syntax highlighting code. It's really highlighted wrong with your correct definition. You should write a bug report email to IDM's support with explaining the problem and attaching your sample file and your wordfile. Interesting is that this wrong highlighting occurs only for files with extension PAS, but not for files with extension DPR or DPK. It looks like there are built-in syntax highlighting definitions for PAS (and P DEF PFC) which are not working correct (UE v11.xx) and which can't be overwritten with a syntax highlighting language definition in the wordfile.
Best regards from an UC/UE/UES for Windows user from Austria