FWD » Core Development » Base Language

**     CA  20210203 Fixed a regression in invokeStandalone or invoke, for Progress.Lang.Class.

**     CA  20210221 Copy 'qualified' annotation for property getter, to emit at the signature.

**     CA  20210428 Fixed o:getClass():invoke() when it needs to be emitted as 'invokeStandalone'.

*/

-->

            isAbstract = isIface or (copy.parent.isAnnotation("abstract") and

                                     getReferenceNoteBoolean(copy.parent.id, "abstract"))

         </action>

         <rule>type == prog.kw_get

            <rule>cls.equals("object") or cls.equals("jobject")

               <action>

                  objtype = copy.parent.getAnnotation("full-java-class")

**                           the imported class name is the same name as the program with the 

**                           import statement.

**     CA  20210609          Fixed extent property used as output/input-output argument.

**     OM  20211111          Added transaction support for finally blocks.

*/

 -->

         <!-- this needs to be done first -->

         <action>setConvertedClassName(file, ooname, fullpkg, classname)</action>

         <!-- map the source file name to the converted class naming info -->

      </rule>

      <rule>relativePath("METHOD_DEF/KW_METHOD/SYMBOL")

**                  later on, when that is injected, the proper javaname is used.

**     GES 20210701 Fix class name references which are to static members of a parent class. This is a 4GL

**                  quirk.

*/

 -->

               <rule on="false">true

                  <!-- explicit class import -->

                  <action>fname = getNoteString("source-file")</action>

               </rule>

            </rule>

         </rule>

            isNote("qualified") and isNote("source-file")

         <action>fname = getNoteString("source-file")</action>

         <rule>nameinfo != null

            <action>oname = nameinfo.getQualifiedName()</action>

         <action>copy.parent.putAnnotation("source-file", getNoteString("source-file"))</action>

         <action>fname = getNoteString("source-file")</action>

         <rule>nameinfo != null

            <action>copy.parent.putAnnotation("full-java-class", nameinfo.getQualifiedName())</action>

      <rule>this.type == prog.enum_value

         <action>fname = getNoteString("source-file")</action>

         <rule>nameinfo != null

            <action>copy.putAnnotation("full-java-class", nameinfo.getQualifiedName())</action>

            <rule on="false">true

               <action>fname = getNoteString("found-in-source-file")</action>

               <rule>nameinfo != null

                  <rule>isNote("refid")

                     <!-- use the javaname at the refid, and not what we thing we should convert to -->

      <rule>this.type == prog.class_event

         <!-- annotate the event name -->

         <action>fname = getNoteString("found-in-source-file")</action>

         <action>refid = getNoteLong("refid")</action>

         <rule>refid == null

          (copy.parent.type == prog.object_invocation and evalLib("input_argument", copy.parent)))

         <action>fname = getNoteString("cls-container")</action>

         <action>refid = getNoteLong("refid")</action>

         <rule>refid == null

            !(isNote("cls-property") or getNoteBoolean("cls-property"))

         <action>fname = getNoteString("found-in-source-file")</action>

         <!-- member vars -->

         <rule>!isNote("refid") and (!isNote("cls-property") or !getNoteBoolean("cls-property"))

**     CA  20210818          Emit 'instantiateUnknownMemptr' in cases when an unknown argument needs to be

**                           passed for a memptr parameter.

**     HC  20211001          Implementation of i18n support.

*/

 -->

               <rule>type == prog.string 

                  <!-- if set, get the class from the classname annotation -->

                  <action>classname = getNoteString("classname")</action>

                     <action>classname = "character"</action>

                  </rule>

               </rule>

            <rule>classname != "date"        and

                  classname != "datetime"    and

                  classname != "datetimetz"  and

                  type != prog.unknown_val

               <!-- insert an intermediate constructor node -->

               <action>

** 088 CA  20200615          Fixed iterator() when starting from a root with a single child.

** 089 CA  20201015          Replaced java.util.Stack with a non-synchronized custom implementation.

** 090 IAS 20210321          Added getImmediateChildren(int type) method 

*/

/*

    */

   public String toStringVerbose()

   {

      // append the token type as a name

      sb.append(" [").append(getSymbolicTokenType()).append("] ");

**     HC  20210401          Made isNumericType and isDateType part of the library.

**     GES 20210610          Added KW_WID_HAND.

**     HC  20211001          Implementation of i18n support.

**     AL2 20211104          DB_REF_NON_STATIC generates case insensitive values.

**     CA  20211214          The AST manager plugin must be context-local, for runtime conversion, as the 

**                           InMemoryRegistryPlugin is not thread-safe.

               case KW_RET_VAL:

                  jcls = "BaseDataType";

                  break;

               // unexpected *_POLY node, error out here

               default:

            }

            break;

         case KW_MEMPTR:

            jcls  = "memptr";

            break;

         case METH_VOID:

         case OO_METH_VOID:

** 004 CA  20191024 Added method support levels and updated the class support level.

** 005 ME  20201023 Added implementation for isType, notType.

**     ME  20210916 Delegate to AssertObject as needed.

*/

/*

import static com.goldencode.p2j.util.TextOps.*;

import static com.goldencode.p2j.util.ErrorManager.silent;

/**

 * Business logic (converted to Java from the 4GL source code in

 * OpenEdge/Core/Assert.cls).

      internalProcedure(Assert.class, "IsEmpty", new Block((Body) () -> {

         notNull(_p1, _p2);

            returnError(ObjectOps.newInstance(AssertionFailedError.class, "II",

                     substitute("&1 must be empty", _p2), 0));

      }));

   public static void notEmpty(final longchar _p1, final character _p2)

   {

      internalProcedure(Assert.class, "NotEmpty", new Block((Body) () -> {

            returnError(ObjectOps.newInstance(AssertionFailedError.class, "II",

                     substitute("&1 cannot be empty", _p2), 0));

      }));

      character p2 = TypeFactory.initInput(_p2);

      internalProcedure(Assert.class, "NotEmpty", new Block((Body) () -> {

            returnError(ObjectOps.newInstance(AssertionFailedError.class, "II",

                     substitute("&1 cannot be empty", p2), 0));

      }));

    */

   public void __core_ByteBucket_execute__()

   {

         onBlockLevel(Condition.ERROR, Action.THROW);

         {

         }

   {

      int64 var = TypeFactory.initInput(_var);

         position.assign(var);

      }));

   }

   @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)

   public void __core_ByteBucket_constructor__()

   {

         __core_ByteBucket_constructor__(new int64(0));

      }));

   }

   {

      int64 defaultCapacity = TypeFactory.initInput(_defaultCapacity);

         __lang_BaseObject_constructor__();

         // just throw a 'matching' error for now until implementation is using the new MemoryOutputStream

      integer initialSize = TypeFactory.initInput(_initialSize);

         __core_ByteBucket_constructor__();

         Assert.isPositive(initialSize, new character("Initial size"));

   @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)

   public void __core_ByteBucket_destructor__()

   {

         destroy();

      }));

   }

   @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)

   public void clear_()

   {

         this.position.assign(1);

         this.size.assign(0);

      }));

   @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)

   public void debug()

   {

         String debugPath = String.format("%sbytebucket-memptr-%d.bin", 

                  EnvironmentOps.getTempDirectory().getValue(), 

   @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)

   public void destroy()

   {

         this.position.assign(1);

         this.size.setUnknown();

      int64 pos = TypeFactory.initInput(_pos);

      int64 size = TypeFactory.initInput(_size);

      object<? extends Memptr> ret = TypeFactory.object(Memptr.class);

      return function(this, "GetBytes", object.class, new Block((Body) () -> {

         if (getSize().longValue() == 0 || size.getValue() == 0)

         {

         else

         {

            memptr ptr = TypeFactory.memptr();

            {

               ptr.setLength(size);

            }

            finally

            {

            }

         }

         returnNormal(ret);

      }));

         }

         finally

         {

         }

      }));

   }

   @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)

   public void initialize()

   {

         clear_();

      }));

   }

   {

      object<? extends ByteBucket> data = TypeFactory.initInput(_data);

         Assert.notNull(data, new character("Input data"));

         ByteBucket bbucket = data.ref();

      int64 ptr = TypeFactory.initInput(_ptr);

      int64 size = TypeFactory.initInput(_size);

         if (!size.isUnknown() && size.longValue() == 0L)

            return;

   {

      memptr ptr = TypeFactory.initInput(_ptr);

         writeBytes(ptr);

      }));

   }

   {

      object<? extends Memptr> mptr = TypeFactory.initInput(_mptr);

         Assert.notNull(_mptr, new character("Data"));

         putBytes(mptr.ref().getPointerValue(), mptr.ref().getSize());

   {

      longchar data = TypeFactory.initInput(_data);

         putString(data, new longchar("UTF-8"));

      }));

   }

      longchar data = TypeFactory.initInput(_data);

      character targetCP = TypeFactory.initInput(_targetCP);

         if (TextOps.isEmpty(data))

            return;

   {

      object<? extends LegacyString> data = TypeFactory.initInput(_data);

         Assert.notNull(data, new character("String data"));

         putString(data.ref().getValue(), new longchar(data.ref().getEncoding()));

   {

      Assert.isPositive(p, new character("Start position"));

      }

      long pos = p.longValue();

      long bytesLeft = data.lengthOf();

      int putAt = 0;

      int offset = (int) ((pos - 1) % MAX_BYTES_PER_ROW);

      int endBucket = (int) ((size.longValue()) / MAX_BYTES_PER_ROW);

      int endOffset = (int) ((size.longValue()) % MAX_BYTES_PER_ROW);

      for (int i = nbucket; i <= endBucket; i++)

      {

         if (numBytes > 0)

         {

            offset = 0;

            putAt += numBytes;

            bytesLeft -= numBytes;

            if (bytesLeft == 0)

               return;

         }

**                  signature.

** 007 ME  20210520 Set hashCode to return the actual string hashCode.

**     ME  20210902 Return default hashCode if unknown, fix empty static method and isNullOrEmpty to use trim.

*/

/*

      object<? extends com.goldencode.p2j.oo.core.collections.Array> p1 = TypeFactory

               .initInput(_p1);

      character p2 = TypeFactory.initInput(_p2);

         object<? extends LegacyClass> clsString = ObjectOps.getLegacyClass(LegacyString.class);

         {

            List<String> entries = new ArrayList<String>();

            for (int i = 1; i <= p1.ref().getSize().intValue(); i++)

            {

               object<? extends _BaseObject_> c = p1.ref().getValue(new integer(i));

               if (c.isUnknown())

               {

               }

               Assert.isType(c, clsString);

               entries.add(ObjectOps.cast(c, LegacyString.class).ref().getValue().getValue());

            }

         }

      }));

   }

   {

      object<? extends com.goldencode.p2j.oo.core.LegacyString>[] p1 = TypeFactory.initInput(_p1);

      character p2 = TypeFactory.initInput(_p2);

      return function(LegacyString.class, "Join", object.class, new Block((Body) () -> {

         // indeterminate array or null delimiter 

            for (object<? extends com.goldencode.p2j.oo.core.LegacyString> s : p1)

            {

               // OE does not check for valid objects in array (will throw error)

               // if any of the strings has a null value the result is always null

               if (!s.isUnknown() && s.ref().getValue().isUnknown())

               {

               }

            }

                              .collect(Collectors.joining(p2.getValue()))));

         }

      }));

   }

   {

      object<? extends com.goldencode.p2j.oo.core.LegacyString> p1 = TypeFactory.initInput(_p1);

      character p2 = TypeFactory.initInput(_p2);

         if (!p1.isUnknown() && (p2.isUnknown() || p1.ref().getValue().isUnknown()))

         {

            // num-entries is unknown, this will throw assert error

                     "I", new integer()));

         }

         else

         {

            // 4GL does not test the string object, 3135 system error will be thrown if null

            String[] entries = TextOps.entries(p1.ref().getValue().getValue(), p2.getValue());

            for (int i = 0; i < entries.length; i++)

            {

            }

         }

      }));

   }

** 003 CA  20191024 Added method support levels and updated the class support level.

** 004 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy

**                  signature.

*/

/*

   {

      return function(this, "ToString", character.class, new Block((Body) () ->

      {

      }));

   }

}

**                  signature.

**     CA  20210609 Updated INPUT/INPUT-OUTPUT parameters to the new approach, where they are explicitly 

**                  initialized at the method's execution, and not at the caller's arguments.

*/

/*

   @Override

   public object<? extends com.goldencode.p2j.oo.lang._BaseObject_> clone()

   {

      return function(this, "Clone", object.class, new Block((Body) () -> {

         cloneElements(clone);

         returnNormal(clone);

      }));

**         20210113 Renamed clear() to clear_(), to follow NameConverter's rules.

** 006 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy

**                  signature.

*/

/*

   {

      integer newSize = TypeFactory.initInput(_newSize);

      internalProcedure(this, "Size", new Block((Body) () -> {

      }));

   }

      return function(this, "AddArray", logical.class, new Block((Body) () -> {

         // OE bug, no check if extent is unknown - size is set to unknown

         {

         }

         returnNormal(true);

      }));

   }

   public void clear_()

   {

      internalProcedure(this, "Clear", new Block((Body) () -> {

      }));

   }

   @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)

   public object<? extends com.goldencode.p2j.oo.lang._BaseObject_> clone()

   {

      return function(this, "Clone", object.class, new Block((Body) () -> {

         cloneElements(clone);

         for (int i = 1; i <= value.length; i++)

         {

            {

               // decrement reference to object

               // set it to invalid

               returnNormal(new logical(true));

            }

         }

      return function(this, "RemoveAll", logical.class, new Block((Body) () -> {

         boolean lAny = false;

         while (iterator.ref().hasNext().booleanValue())

         {

      }));

   }

   @LegacySignature(type = Type.METHOD, name = "SetValue", parameters = {

            @LegacyParameter(name = "p1", type = "OBJECT", qualified = "progress.lang.object", mode = "INPUT") })

   @LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)

   public void setValue(final object<? extends com.goldencode.p2j.oo.lang._BaseObject_> _p1)

   {

      internalProcedure(this, "SetValue", new Block((Body) () -> {

      }));

   }

      internalProcedure(this, "SetValue", new Block((Body) () -> {

         {

            if (autoExpand.booleanValue())

            {

            }

            else

            {

         }

         // decrement reference to previous object if any

         ArrayAssigner.assignSingle(value, p2, p1);

         // increment reference to object

      }));

   }

** 002 CA  20210113 Renamed Iiterator.next to Iiterator.next_, to follow NameConverter's rules.

** 003 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy

**                  signature.

*/

/*

   {

      return function(ArrayIterator.class, this, "HasNext", logical.class, new Block((Body) () ->

      {

      }));

   }

   {

      return function(ArrayIterator.class, this, "Next", object.class, new Block((Body) () ->

      {

         returnNormal(iteratedArray.ref().getValue(currentExtent));

      }));

   }

** 004 ME  20210325 Increment/decrement object references (key/value) when added/removed.

**     ME  20210521 Use a 'key' object with hashCode/equals overrides.

**     ME  20210902 Do not decrement reference for input parameter on remove.

*/

/*

   {

      object<? extends com.goldencode.p2j.oo.lang._BaseObject_> poKey = TypeFactory

               .initInput(_poKey);

      return function(LegacyMap.class, this, "Get", object.class, new Block((Body) () ->

      {

         keyobject key = new keyobject(poKey);

         if (map.containsKey(key))

      }));

   }

               .initInput(_poKey);

      object<? extends com.goldencode.p2j.oo.lang._BaseObject_> poValue = TypeFactory

               .initInput(_poValue);

      return function(LegacyMap.class, this, "Put", object.class, new Block((Body) () ->

      {

         if (poKey.ref().equals(this))

            undoThrow(AppError.newInstance(new character("A Map cannot have itself as key.")));

         {

            ObjectOps.increment(poValue.ref());

         }

         {

            ObjectOps.increment(poKey.ref());

            size++;

         }

      }));

   }

   {

      object<? extends com.goldencode.p2j.oo.lang._BaseObject_> poKey = TypeFactory

               .initInput(_poKey);

      return function(LegacyMap.class, this, "Remove", object.class, new Block((Body) () ->

      {

         if (!poKey.isValid().booleanValue())

            returnNormal(new object());

            size--;

      }));

   }

**     ME   20210204 Complete implementation as of OE12.2.

** 005 CA   20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy

**                   signature.

*/

/*

         this.fileName.assign(filename);

      }));

   }

   {

      internalProcedure(FileInputStream.class, this, "Close", new Block((Body) () -> 

      {

         super.close();

      }));

   }

            undoThrow(SysError.newInstance("Invalid value specified for parameter 'length' of method or constructor 'Read'", 18193, false, true));

         }

         long toRead = bytesLeft;

         if (bytesLeft > 0)

         undoThrow(SysError.newInstance("Cannot invoke Read method in 'Progress.IO.FileInputStream' because it is not implemented", 18192, false, false));

      }));

   }

}

**     CA  20210816 Fixed clone() - object references must be incremented.

**     OM  20210825 getJsonDataTypeName() is static now.

**     VVT 20210917 Javadoc fixed. 

*/

/*

   @Override

   public object<? extends com.goldencode.p2j.oo.lang._BaseObject_> clone()

   {

      return function(this, "Clone", object.class, new Block((Body) () ->

      {

         for (Map.Entry<String, Object> prop : properties.entrySet())

         {

            Object val = prop.getValue();

** 007 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy signature.

**     OM  20210329 FIX-CODEPAGE is emitted as static method call to accomodate dereferenciation cases.

**     CA  20210709 JSON parse must use a pristine byte stream and use the reader to decode it.

**     CA  20220120 Do not used TypeFactory.object when the OO reference must not be tracked or registered.

**                  Do not use TypeFactory.object for internal usages, use ObjectVar if the reference must 

**                  be tracked.

         }

         // empty string does not throw as for character/longchar so parse the string directly

         try

         {

            res.assign(JsonBackend.instance().parse(source.getString(1).toStringMessage()));

**     GES 20200605 Fixed isValidEnum() processing.

** 009 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy signature.

**     OM  20210225 Dropped duplicated error code.

*/

/*

    * 

    * @return   See above.

    */

   {

      @LegacyParameter(name = "propName", type = "CHARACTER", mode = "INPUT")

   })

    * 

    * @return   See above.

    */

   {

      @LegacyParameter(name = "propName", type = "CHARACTER", mode = "INPUT"),

   })

   @LegacyResourceSupport(supportLvl = CVT_LVL_PARTIAL|RT_LVL_STUB)

   {

      // TODO:

      return new unknown();

    * 

    * @return   See above.

    */

   {

      @LegacyParameter(name = "instance", type = "OBJECT", qualified = "Progress.Lang.Object", mode = "INPUT"),

      @LegacyParameter(name = "propName", type = "CHARACTER", mode = "INPUT"),

    * 

    * @return   See above.

    */

   {

      @LegacyParameter(name = "instance", type = "OBJECT", qualified = "Progress.Lang.Object", mode = "INPUT"),

      @LegacyParameter(name = "propName", type = "CHARACTER", mode = "INPUT"),

   })

   @LegacyResourceSupport(supportLvl = CVT_LVL_PARTIAL|RT_LVL_STUB)

   public Object getPropertyValue(object<? extends _BaseObject_> instance, 

                                  character propName, 

   {

      // TODO:

      return new unknown();

   }

   /**

    * Resolve the legacy class from the given name.

    * 

    *            

    * @return    Any returned value, or unknown if the method is void.

    */

   {

      @LegacyParameter(name = "method", type = "CHARACTER", mode = "INPUT")

   })

    *            

    * @return    Any returned value, or unknown if the method is void.

    */

   {

      @LegacyParameter(name = "ref",    type = "OBJECT", mode = "INPUT", qualified = "Progress.Lang.Object"),

      @LegacyParameter(name = "parms",  type = "OBJECT", mode = "INPUT", qualified = "Progress.Lang.ParameterList")

    *            

    * @return    Any returned value, or unknown if the method is void.

    */

   {

      @LegacyParameter(name = "ref",    type = "OBJECT",    mode = "INPUT", qualified = "Progress.Lang.Object"),

      @LegacyParameter(name = "method", type = "CHARACTER", mode = "INPUT"),

    *            

    * @return    Any returned value, or unknown if the method is void.

    */

   {

      @LegacyParameter(name = "ref",    type = "OBJECT",    mode = "INPUT", qualified = "Progress.Lang.Object"),

      @LegacyParameter(name = "method", type = "CHARACTER", mode = "INPUT"),

   @LegacySignature(type = Type.METHOD, name = "SetPropertyValue", parameters = 

   {

      @LegacyParameter(name = "pname", type = "CHARACTER", mode = "INPUT"),

      internalProcedure(LegacyClass.class, this, "SetPropertyValue", new Block());

   }

}

** 

** 003 CA  20210221 Fixed 'qualified', 'extent' and 'returns' annotations at the legacy

**                  signature.

*/

/*

   {

      longchar pcMle = TypeFactory.initInput(_pcMle);

      object<? extends com.goldencode.p2j.oo.core.SerializationFormatEnum> poSerializedAs = TypeFactory.initInput(_poSerializedAs);

      return function(MediaLinkEntity.class, "Deserialize", object.class, new Block((Body) () -> 

      {

         {

            undoThrow(AppError.newInstance(

                     TextOps.substitute("Unsupported MLE serialization type &1",

                     new integer(0)));

         }

         object<ObjectModelParser> parser = ObjectOps.newInstance(ObjectModelParser.class);

         object<JsonObject> jsonObj = ObjectOps.cast(parser.ref().parse(pcMle), JsonObject.class);