ABAP: String Operations: How can I replace a closing tag with its corresponding opening tag?

To make things clearer and easier, I have a method which has 1 changing parameter. The imported string contains text and text formatting options, the method should recognize the closing tags (always </>) and change them based on the corresponding opening tags, which can be <B>, <I>, <U>, to become respectively </B>, </I>, </U>.

For example:

• the input string:
  Lorem <I>ipsum dolor sit amet</>, consetetur <B>sadipscing elitr</>, sed <U>diam</> nonumy eirmod tempor <B><I><U>invidunt</></></> ut labore et <B>dolore</> magna aliquyam erat, sed diam voluptua.
• should become:
  Lorem <I>ipsum dolor sit amet</I>, consetetur <B>sadipscing elitr</B>, sed <U>diam</U> nonumy eirmod tempor <B><I><U>invidunt</U></I></B> ut labore et <B>dolore</B> magna aliquyam erat, sed diam voluptua.

I tried many manipulations including:

• finding the last occurrence of the opening tag and determine the one that should be used based on the highest offset, and then truncating the string to the offset,
• trying to inverse the string and find the closest opening tag.

I don't know if it is the simpliest/most effective solution, but I have run some tests and it handles also the nested tags properly.

The idea is: we run through the string and keep track of the opening tags in an internal table. The opening tags are like < x> (without the space, x can be any character except '/'). Once we find a closing tag (like </>) this will be replaced (in place) with < /x> (again without the space), where x is the last opening tag (from the internal table).

The method definition:

CLASS-METHODS closing_tag IMPORTING iv_html        TYPE string
                          RETURNING VALUE(rv_html) TYPE string.

And the implementation:

METHOD closing_tag.

DATA tags TYPE STANDARD TABLE OF char01.
DATA position TYPE i VALUE 0.
DATA position_temp TYPE i.

rv_html = iv_html.
WHILE position < strlen( rv_html ) - 1.
  IF rv_html+position(1) = '<'.
    position_temp = position + 2.
    " Check whether it is a html tag like <x>
    IF rv_html+position_temp(1) = '>'.
      SUBTRACT 1 FROM position_temp.
      IF rv_html+position_temp(1) = '/'.
        " Closing tag => retrive last opening tab
        IF tags IS INITIAL.
          " there was no opening tag !
          ADD 3 TO position.
        ELSE.
          DATA(tag) = tags[ lines( tags ) ].
          REPLACE FIRST OCCURRENCE OF '</>'
                  IN rv_html
                  WITH |</| && tag && |>|.
          DELETE tags INDEX lines( tags ).
          ADD 4 TO position.
        ENDIF.
      ELSE.
        " Opening tag => store it
        APPEND rv_html+position_temp(1) TO tags.
        ADD 3 TO position.
      ENDIF.
    ELSE.
      " There was a '<' but no '>' 2 characters after so just move on.
      ADD 1 TO position.
    ENDIF.
  ELSE.
    ADD 1 TO position.
  ENDIF.
ENDWHILE.

  ENDMETHOD.

To keep in mind:
My assumption is that every tag is in format of < x>, so one character only in the bracelets. If that is not true (I don't habe much idea about html tags), than the logic has to be modified accordingly.

Not fancy, but it does the job. Might need to tweak the regex in future, if more than one letter tag names occur.

DATA lv_input TYPE string. "your input string
DATA lv_result TYPE string.
DATA lt_match TYPE match_result_tab.
DATA lw_match TYPE match_result.
DATA lv_offset TYPE i.
DATA lt_tag_name TYPE STANDARD TABLE OF string.
DATA lv_tag_name TYPE string.

"extract all tag names
FIND ALL OCCURRENCES OF REGEX '<([A-Za-z])>' IN lv_input RESULTS lt_match.
lv_result = lv_input.
"replace unnamed closing tags with placeholder
REPLACE ALL OCCURRENCES OF REGEX '<([//])>' IN lv_result WITH '&'.

LOOP AT lt_match INTO lw_match.
  lv_offset = lw_match-submatches[ 1 ]-offset.
  "assuming tag names are one character long
  lv_tag_name = lv_input+lv_offset(1).
  APPEND lv_tag_name TO lt_tag_name.
ENDLOOP.

LOOP AT lt_tag_name INTO lv_tag_name.
  REPLACE FIRST OCCURRENCE OF '&' IN lv_result WITH |</{ lv_tag_name }>|.
ENDLOOP.