FWD » Core Development » Base Language

The conversion fails because of code in record_scoping_prep.rules which assumes the buffer annotation is in the copy.parent.prevSibling which in the case of
function func0 returns char (buffer for book) forward. is not true and the prevSibling node does not exist
A null check for copy.parent.prevSibling and getting the annotation from the current node in the case this is null solved the problem.
However the code is still not converted correctly or persistent:

Example:

forward.p

FUNCTION doubler RETURNS INTEGER (buffer for book) FORWARD.
FUNCTION doubler RETURNS INTEGER (buffer bb for book). end.

FUNCTION doubler2 RETURNS INTEGER (buffer cc for book) FORWARD.
FUNCTION doubler2 RETURNS INTEGER (buffer cc for book). end.

   public integer doubler(final Book.Buf bb)
   {
      return function(integer.class, new Block()
      {
         public void init()
         {
            Winhand.this.bb = bb;
         }

         public void body()
         {
            RecordBuffer.openScope(bb, book);
         }
      });
   }

This happens because book is put as a javaname annotation together with bb which are then are used as parameter for emiting RecordBuffer.openScope statement

in the second case it converts correctly to:

   public integer doubler2(final Book.Buf ccBuf2)
   {
      return function(integer.class, new Block()
      {
         public void init()
         {
            Winhand.this.ccBuf2 = ccBuf2;
         }
         public void body()
         {
            RecordBuffer.openScope(ccBuf2, ccBuf2);
         }
      });
   }

but in this case the javaname annotations are emitted correctly to ccBuf2.
I'll think on how can this be fixed.

Actually, both results look wrong. doubler2() gets an openScope() with the same buffer name passed twice. That may be OK, but is definitely not what we want. The core remaining issue is that there should not ever be 2 buffers emitted in an openScope() for a single buffer parameter.

Keep in mind that the FORWARD declaration should not be changing buffer scoping at all. My guess is that somewhere we are not bypassing the addition of a new buffer when it is a FORWARD function.

The update looks OK, is going through conversion regression testing now.

Update has passed conversion regression testing, please check in and distribute.

Commited to bazaar as revision number 10209.