Creating OBX Segments from Text

######################################################################
# Name: tpsSplitOBX_br
#
# Purpose: Split an OBX segment into multiple OBX, based on the presence of
#         line breaks (.br) in the OBX segment. Each line will be placed in
#         its own new OBX segment and the sequence of OBX segments will be maintained.
#
#         Other OBX segments with no embedded .br may come before and after the affected
#         OBX segment, so the OBX sequence must be readjusted accordingly.
#
# UPoC type: tps
#
# Use:              Pre-Xlate
# Args: tps keyedlist containing the following keys:
#       MODE    run mode (”start”, “run” or “time”)
#       MSGID   message handle
#       ARGS    user-supplied arguments:
#               None
#
# Returns: tps disposition list:
#          CONTINUE
#
proc tpsSplitOBX_br { args } {
   keylget args MODE mode               ;# Fetch mode
   
   set dispList {} ;# Nothing to return
   
   switch -exact — $mode {
       start {
           # Perform special init functions
           # N.B.: there may or may not be a MSGID key in args
       }
       
       run {
           # ‘run’ mode always has a MSGID; fetch and process it
           keylget args MSGID mh
           set msg [msgget $mh]
           set segmentList [split $msg r]
           
           # Get the field separator
           set fldSep [string index $msg 3]
           
           set newmsg {}       ;# Buffer to contain the modified messsage
           set obxCount 0      ;# To keep track of the OBX segments
           set tokensList {}   ;# To keep track of the OBX pieces
           
           foreach segment $segmentList {
               set segmentType [string range $segment 0 2]
               
               switch -exact — $segmentType {
                   “OBX” {
                       # The only segment to do manipulations on
                       # Break the segment in a list of fields
                       set OBXflds [split $segment $fldSep]
                       
                       # To avoid lreplace errors, make sure the list has
                       # at least 5 elements by appending empty elements until
                       # it does.
                       
                       while {[llength $OBXflds] >>OBX.5: $OBX5 <<>>new OBX.5: $newOBX5 <<>> $tokensList <<<
                       # Iterate over the list and place each token in its own OBX segment,
                       # while maintaining the proper sequencing
                       
                       foreach token $tokensList {
                           incr obxCount
                           # Place the count in OBX.1 and the token in OBX.5
                           set OBXflds [lreplace $OBXflds 1 1 $obxCount]
                           set OBXflds [lreplace $OBXflds 5 5 $token]
                           
                           # Put the OBX segment back together
                           set segment [join $OBXflds $fldSep]
                           # echo "Modified OBX segment: $segment"
                           # Add the segment to the new message
                           lappend newmsg $segment
                       }
                       
                   }
                   
                   default {
                       # Any other segment we just pass as is,
                       # skipping empty segments
                       
                       if {![string equal $segmentType ""]} {
                           lappend newmsg $segment
                       }
                   }
               }
           }
           
           set newmsg [join $newmsg "r"]
           
           # Put modified message in message handle
           
           msgset $mh $newmsg
           lappend dispList "CONTINUE $mh"
       }
       
       time {
           # Timer-based processing
           # N.B.: there may or may not be a MSGID key in args
       }
       
       shutdown {
           # Doing some clean-up work
       }
   }
   
   return $dispList
}

set NTE3 [lindex $xlateInVals 0]
set NTE3 [string map {\.br\ ~} $NTE3]
set nte_list [split $NTE3 “~”]
set num_vals [llength $nte_list]
set xlateOutVals [list $nte_list $num_vals]

set nte_list [lindex $xlateInVals 0]
set s9 [lindex $xlateInVals 1]
set obx5 [lindex $nte_list $s9]
incr s9
set xlateOutVals [list $obx5 $s9]