Suggestion - implement FORWARD keyword for records.

[ad1mt]

Here's something I needed while working on a library...
implement FORWARD keyword for records... 
I know its non-standard, but it prevented me from doing something that would have been really useful.

[cdbc]

Hi
PRecord = ^TRecord;
Doesn't work for you???
Regards Benny

[Thaddy]

What would be very useful... Example plz.

[marcov]

Currently forward declarations for storage types are only for types from which the storage size is known from the forward declaration.

i.e. a pointer (in the disguise of a class instance ref). This is not possible for a Record, since to embed that in another class of structure the size is required.

To fix that would require a radical different multipass parser model, which is beyond the scope of this project atm.

Similarly forward procedure declarations also have the base declaration to call it, for exactly the same reasons.

[PascalDragon]

Here's something I needed while working on a library...
implement FORWARD keyword for records... 
I know its non-standard, but it prevented me from doing something that would have been really useful.

And that is something that will not be changed. The compiler must know the size of a record to be able to embed it somewhere else (without using a Pointer) and both Pascal and FPC are designed as a single pass language (in case of FPC as far as the parser is concerned).

[BeniBela]

And that is something that will not be changed. The compiler must know the size of a record to be able to embed it somewhere else (without using a Pointer) and both Pascal and FPC are designed as a single pass language (in case of FPC as far as the parser is concerned).

It does not need to change. The compiler could just support forward declarations without embedding.

And if the user tries to use the record in a field declaration, it gives an error "embedding not supported for forward types"



Such forward declarations are extremely useful. Then we could compile this:

Code: Pascal  [Select][+][-]

1.  
2. type
3. //TB = record; forward;
4.  
5. TA = record
6.   function equals(const b: TB): boolean;
7. end;
8. TB = record
9.   function equals(const a: TA): boolean;
10. end;
11.  
12.  

[440bx]

Such forward declarations are extremely useful. Then we could compile this:

I see a conceptual problem with that code.   Specifically, there should be only ONE "Equals" function that takes a TA and TB as parameters.  Not two Equals functions that take different parameters yet, from the looks of it, are supposed to do the same thing.