oRefactorFuncLib.pkg

Use cRefactorFuncLib.pkg
//Use SupplementalRefactoringClasses.pkg
// *** Refactor Function Library ***
//     The object below contains all public refactoring functions.

/*  RULES FOR USING META-TAGS:

    There are four parameters accepted by the procdure RegisterInterface that is used to
    collect info about a function when the program starts. The first one
    is a handle that cannot be used for our purposes. The second one is the function name.
    The third contains the types and names of the parameters and return type for the function.
    That leaves only one more RegisterInterface param we can use, and that is the "sComment".
    The { Description } meta-tag content is what ends up in the sComment parameter.

    As we need to handle more than four parameters, the RegisterInterface has been made in
    such a way that other meta-tags embedded within the { Description } meta-tag, are
    parsed and moved to various struct members.

    Important Note: For the { Description... meta-tag Aligned Multiline Strings are used
                    That is strings that starts and ended with a """ (triple-quote character).
                    Embedded in { Description } meta-tags, *other* meta-tags are being used
                    to describe other characterestica for a function. Those are all parts
                    that are parsed by the RegisterInterface class procedure.

    Studio Note:    The Studio (DF 25) gets very confused when tripple quotes are used with the
                    { Description } meta-tag. Both the Code Explorer and Code Completions
                    stops working. Also the Problem Resolution panel shows issues for
                    text inside the meta-tag.
                    It is therefor advised to edit and test new refactor functions in
                    another package, and then publish it here.

    The {Published} meta-tag must be set to True for a function to show up at all in function
    lists of the running program.
    Sample:
    { Published = True }

    The { Description } meta-tag is used as a compound tag, as it will contain other meta-tags.
    As described above it starts with a tripple quote, and ends with a tripple quote symbol.
    Sample:
    { Description = """
        Some text that can span
        several lines, yada-yada-yada.
        """ }

        The { MethodType } tag describes the type of function, as this is vital for the
        refactoring engine to know how a function should be called. It must be one of the members
        from this list;
            eStandardFunction    - One source line at a time will be passed for these functions.
            eRemoveFunction      - One source line at a time will be passed for these functions.
            eEditorFunction      - A source file as a string array will be passed
            eReportFunction      - A source file as a string array. Makes no source changes.
            eReportFunctionAll   - Makes no source changes.
            eOtherFunction       - A source file as a string array will be passed.
            eOtherFunctionAll    - All selected files as a string array will be passed.
        Sample:
        { MethodType = eStandardFunction }

          { SummaryText } A short description text that is used by the cRefactorEngine post run report summary.
          Sample:
          { SummaryText = Split line If/Else line }

          When a refactoring function uses parameters for the "sParameter" param, possible
          values are entered in an { EnumList } meta-tag.
          If an { EnumList } meta-tag is used, it needs to be followed by two other meta-tags;
          { InitialValue } This is the default value from the EnumList, and
          { ParamHelp } This will be the help text presented to the user when hovering the mouse
                        over the grid column item. This needs to be the last item.
                        Write '\n' to insert a carrige return characters to line up ParamHelp
                        text.
        Sample:
        { EnumList = "eSplitBySpaceAndSemicolon, eSplitBySemicolon, eSplitToBeginEndBlock" }
        { InitialValue = eSplitToBeginEndBlock }
        { ParamHelp = Valid Values;
        \neSplitBySpaceAndSemicolon - Split line with space and semicolon,
        \neSplitBySemicolon - Split line with semicolon,
        \neSplitToBeginEndBlock - Use a Begin/End block }
        """ }
*/

// Warning: Do not change the following object line as it is searched for,
//          by the cExportImportFunctions logic.
Object oRefactorFuncLib is a cRefactorFuncLib

    /* *** User defined functions are included here ***
           Use the file to add your own special refactoring function(s) that are particular to
           a special code base/project, and has no general interest.
    */
    #Include UserDefinedRefactorFunctions.pkg


    /*    *** General Purpose Refactoring Functions ***

              These are the pre-made refactoring functions
              delivered with the workspace. If there is a need
              to add private functions that is of no public
              interest, add them to thís package:
              UserDefinedRefactorFunctions.pkg

              If however, new functions are developed that could
              be of public interest, please use the TestBench's
              'JSON Export/Import facility to export new functions
              and email the JSON file to: support@rdctools.com

              There must be at least *one blank line* between each
              function. The blank lines are used by the
              cExportImportFunctions logic when scanning the source code.
    */

    { Published = False }
    { Description = """
        Note: ALWAYS SELECT THIS FUNCTION, PRIOR USAGE OF OTHER REFACTORING FUNCTIONS!
        Else other refactoring functions will not work properly.
        Inserts a missing space between a closing parenthesis/bracket and a keyword.
        Example: ))Begin -> )) Begin  or  ]Set -> ] Set
        The DataFlex compiler allows this, but the missing space causes refactoring
        functions to fail, because the tokenizer cannot split the tokens correctly.
        { MethodType = eStandardFunction }
        { SummaryText = ALWAYS USE WITH THE FIRST RUN IN A WORKSPACE! Adds a missing space (blank) after a ')' or a ']', and before a keyword }
        """ }
    Function A_InsertSpaceAfterParenthesis String ByRef sLine String sParameter Returns Boolean
        String sChar sText
        Integer iPos iAsc iIndent
        Boolean bChanged

        tTokenizer TokenizerData
        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True) Begin
            Function_Return False
        End

        // Work on the original sLine directly, scanning for ')' followed by a letter or underscore.
        // Use a simple forward search with Pos, starting after the last match each time.
        // We track indentation to know where code starts, but scan the full sLine.
        Move False to bChanged
        Move (Pos(")", sLine)) to iPos
        While (iPos <> 0 and iPos < Length(sLine))
            Move (Mid(sLine, 1, (iPos + 1))) to sChar
            Move (Ascii(sChar)) to iAsc
            // A-Z = 65-90, a-z = 97-122, _ = 95
            If ((iAsc >= 65 and iAsc <= 90) or (iAsc >= 97 and iAsc <= 122) or (iAsc = 95)) Begin
                Move (Insert(CS_S, sLine, (iPos + 1))) to sLine
                Move True to bChanged
            End
            // Search for next ')' after current position
            Move (Length(sLine)) to iIndent
            If ((iPos + 1) < iIndent) Begin
                Move (Mid(sLine, (iIndent - iPos), (iPos + 1))) to sText
                Move (Pos(")", sText)) to iIndent
                If (iIndent <> 0) Begin
                    Move (iPos + iIndent) to iPos
                End
                Else Begin
                    Move 0 to iPos
                End
            End
            Else Begin
                Move 0 to iPos
            End
        Loop

        // Also handle ']' (closing square bracket) followed immediately by a letter or underscore.
        // Example: [Found  ]Set -> [Found  ] Set
        Move (Pos("]", sLine)) to iPos
        While (iPos <> 0 and iPos < Length(sLine))
            Move (Mid(sLine, 1, (iPos + 1))) to sChar
            Move (Ascii(sChar)) to iAsc
            // A-Z = 65-90, a-z = 97-122, _ = 95
            If ((iAsc >= 65 and iAsc <= 90) or (iAsc >= 97 and iAsc <= 122) or (iAsc = 95)) Begin
                Move (Insert(CS_S, sLine, (iPos + 1))) to sLine
                Move True to bChanged
            End
            // Search for next ']' after current position
            Move (Length(sLine)) to iIndent
            If ((iPos + 1) < iIndent) Begin
                Move (Mid(sLine, (iIndent - iPos), (iPos + 1))) to sText
                Move (Pos("]", sText)) to iIndent
                If (iIndent <> 0) Begin
                    Move (iPos + iIndent) to iPos
                End
                Else Begin
                    Move 0 to iPos
                End
            End
            Else Begin
                Move 0 to iPos
            End
        Loop

        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Calc/MoveInt/MoveStr/MoveNum/MoveReal -> 'Move' command.
        The legacy commands compiles but does not work with the Studio's statement completion.
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Calc/MoveInt/MoveStr/MoveReal -> Move }
        { ModRecipe = 4533 | command: Calc }
        """ }
    Function ChangeCalcToMoveStatement String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged bFound
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        // Check if line contains one of the keywords and that none of the keywords are within quotes.
        Get IsKeywordInLine "calc|moveint|movenum|movereal|movestr" TokenizerData.asLineTokens to bFound
        If (bFound = False) Begin
            Function_Return False
        End

        Move False to bChanged
        If (bChanged = False) Get _SubstituteCalcKeyword (&sLine) "calc"    4 to bChanged
        If (bChanged = False) Get _SubstituteCalcKeyword (&sLine) "moveint" 7 to bChanged
        If (bChanged = False) Get _SubstituteCalcKeyword (&sLine) "movenum" 7 to bChanged
        If (bChanged = False) Get _SubstituteCalcKeyword (&sLine) "movereal" 8 to bChanged
        If (bChanged = False and TokenizerData.bIsMoveStatement = False) Begin
            Get _SubstituteCalcKeyword (&sLine) "movestr" 7 to bChanged
        End

        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Current_Object -> Self
        Replaces the legacy keyword 'Current_Object' with 'Self'
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Legacy Current_Object -> Self }
        """ }
    Function ChangeCurrent_ObjectToSelf String ByRef sLine String sParameter Returns Boolean
        String sChar
        Boolean bFound
        Integer iPos iItem
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Move (SearchArray(CS_Current_Object, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem = -1) Begin
            Move (Pos(Lowercase(CS_Current_Object), Lowercase(sLine))) to iPos
            If (iPos <> 0) Begin
                Move (Mid(sLine, 1, (iPos -1))) to sChar
                If (sChar <> "(") Begin
                    Function_Return False
                End
            End
            Else Begin
                Function_Return False
            End
        End

        Get ReplaceLineToken TokenizerData sLine CS_Current_Object CS_Self to sLine
        // Note! We call ourself recursively if there are more than one "current_object".
        Move (Pos(Lowercase(CS_Current_Object), Lowercase(sLine))) to iPos
        If (iPos <> 0) Begin
            Get ChangeCurrent_ObjectToSelf (&sLine) "" to bFound
        End

        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Replaces legacy DfTrue and DFFalse with True or False
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = DFTrue -> True }
        """ }
    Function ChangeDfTrueDfFalse String ByRef sLine String sParameter Returns Boolean
        Boolean bFound
        String sNewBoolean
        Integer iPos
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData

        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        // Note: The sKeywords string must be separated by "|" _and_ end with a "|".
        Get IsKeywordInLine (CS_DfTrue + CS_D + CS_DfFalse + CS_D) TokenizerData.asLineTokens to bFound
        If (bFound = False) Begin
            Function_Return False
        End

        Move (Trim(sLine)) to sLine
        Repeat
            Move CS_True to sNewBoolean
            Move (Pos(Lowercase(CS_DfTrue), Lowercase(TokenizerData.sOverstrikeLine))) to iPos
            If (iPos = 0) Begin
                Move (Pos(Lowercase(CS_DfFalse), Lowercase(TokenizerData.sOverstrikeLine))) to iPos
                Move CS_False to sNewBoolean
            End
            If (iPos <> 0) Begin
                Move (Overstrike("||" + sNewBoolean, sLine, iPos)) to sLine
                Move (Replace("||", sLine, "")) to sLine
                Move (Overstrike("||" + sNewBoolean, TokenizerData.sOverstrikeLine, iPos)) to TokenizerData.sOverstrikeLine
                Move (Replace("||", TokenizerData.sOverstrikeLine, "")) to TokenizerData.sOverstrikeLine
            End
        Until (iPos = 0)

        Move (TokenizerData.sIndentation + String(sLine)) to sLine
        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Replaces legacy GetAddress command with function AddressOf.
        Example: GetAddress of sVal to aAddress --> Move (AddressOf(sVal)) to aAddress
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = GetAddress -> (AddressOf( }
        { ModRecipe = 4533 | command: GetAddress }
        """ }
    Function ChangeGetAddress String ByRef sLine String sParameter Returns Boolean
        Boolean bFound
        tTokenizer TokenizerData
        tToken Token

        Get pTokenizer to TokenizerData

        // Deliberately NO bIsInFunction/bIsInProcedure guard here - those are the
        // lexer's sticky inside-a-body scope flags, and a GetAddress command lives
        // almost exclusively inside method bodies. The old guard disabled the
        // function on every real occurrence (cWinFunc.pkg was never changed), while
        // the single-line fixtures carry no scope, so the tests stayed green.
        If (TokenizerData.bLineIsReady = True or TokenizerData.bHasEndSemiColon = True or ;
            TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Get IsKeywordInLine (CS_GetAddress + CS_D) TokenizerData.asLineTokens to bFound
        If (bFound = False) Begin
            Function_Return False
        End

        // What DOES need protecting is a line that merely MENTIONS GetAddress - a
        // declaration ("Function GetAddress Returns String") or an expression use
        // ("Entry_Item (GetAddress(...))"). Require the COMMAND position, like
        // ChangeSysdate4. FirstLeftCommand ONLY: an If-prefixed nose form is left
        // untouched on purpose - the rebuild below is whole-line and would lose it.
        Move TokenizerData.FirstLeftCommand to Token
        If (Lowercase(Token.sCode) <> Lowercase(CS_GetAddress)) Begin
            Function_Return False
        End

        // The rebuild needs both sides. The no-"of" variant ("GetAddress sVal to
        // pVal") leaves OfStatement empty and would emit a broken
        // "Move (AddressOf())" - leave that shape untouched.
        If (TokenizerData.OfStatement.sCode = "" or TokenizerData.ToStatement.sCode = "") Begin
            Function_Return False
        End

        If (TokenizerData.sEndComment <> "") Begin
            Move (TokenizerData.sIndentation + CS_Move * "(" + CS_AddressOf + "(" + TokenizerData.OfStatement.sCode + "))" * CS_To * String(TokenizerData.ToStatement.sCode) * String(TokenizerData.sEndComment)) to sLine
        End
        Else Begin
            Move (TokenizerData.sIndentation + CS_Move * "(" + CS_AddressOf + "(" + TokenizerData.OfStatement.sCode + "))" * CS_To * String(TokenizerData.ToStatement.sCode)) to sLine
        End

        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Changes command "IFNOT" into an expression
        Example: IFNOT Found Begin -->  If (Not(Found)) Begin
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = IFNOT command -> If (not('indicator')) }
        """ }
    Function ChangeIfNotCommandToExpression String ByRef sLine String sParameter Returns Boolean
        tTokenizer TokenizerData
        Integer iItem iPos iSize iCount
        String sCode sToken
        
        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Move (SearchArray("IFNOT", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem = -1) Begin
            Function_Return False
        End
        
        Move sLine to sCode
        // Locate IFNOT boundary-aware on the MASKED line (position-aligned
        // with sLine) via _FindKeywordPos - a bare Pos could match inside an
        // identifier or a string literal before the real IFNOT (2026-06-10
        // audit).
        Get _FindKeywordPos (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) "ifnot" True 1 to iPos
        Move (Left(sCode, (iPos + Length("ifnot")))) to sCode
        If (iPos <> 0) Begin
            Move (Overstrike("|||||", sCode, iPos)) to sCode
            Move (Replace("|||||", sCode, CS_If)) to sCode
            Increment iItem
            Move TokenizerData.asLineTokens[iItem] to sToken
            Append sCode "(" CS_Not "(" sToken ")) "
            Move (TokenizerData.iTokenCount) to iSize
            Decrement iSize
            For iCount from (iItem +1) to iSize
                Append sCode TokenizerData.asLineTokens[iCount] CS_S
            Loop
        End
        Move (RTrim(sCode)) to sCode
        If (sLine <> sCode) Begin
            Move sCode to sLine
            Function_Return True
        End
        Function_Return False
    End_Function
    
    { Published = True }
    { Description = """
        Changes legacy Insert command to use the function Insert.
        Example: Insert "," In sText At 2 --> Move (Insert(",", sText, 2)) to sText
        If sOne Eq "A" Insert "B" in sOne at 2 --> If sOne Eq "A" Move (Insert("B", sOne, 2)) to sOne
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Insert command -> (Insert( }
        { ModRecipe = 4531 | command: Insert }
        """ }
    Function ChangeInsertCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged bFound
        String sNose sLineLC sToken sVar1 sVar2 sText sInPos
        Integer iPos iItem
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Move (SearchArray(CS_Insert, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem = -1) Begin
            Function_Return False
        End

        Move (Trim(sLine)) to sLine
        Move "" to sNose
        Move (Lowercase(sLine)) to sLineLC
        // If anything left of the CS_Insert command, save it in "sNose" (start string)
        If (iItem > 0) Begin
            Move (Pos(Lowercase(CS_Insert), sLineLC)) to iPos
            Move (Left(sLine, (iPos -1))) to sNose
            Move (Replace(sNose, sLine, "")) to sLine
        End

        // Remove the CS_Insert command
        Move TokenizerData.asLineTokens[iItem] to sToken
        Move (Replace(sToken, sLine, "")) to sLine
        // Get the first variable
        Move TokenizerData.asLineTokens[iItem + 1] to sVar1

        // Find and remove the "IN" keyword.
        Move (SearchArray(CS_In, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Move TokenizerData.asLineTokens[iItem] to sToken
            Move (Replace(sToken, sLine, "")) to sLine
            Move TokenizerData.asLineTokens[iItem + 1] to sVar2
        End

        // Find and remove the "AT" keyword, and save the next parameter which is the position to insert at.
        Move (SearchArray(CS_At, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Move TokenizerData.asLineTokens[iItem] to sToken
            Move (Replace(sToken, sLine, "")) to sLine
            // Keep the position as a STRING (verbatim token). It can be a variable or expression - 'at iIndex',
            // 'at (Length(s))' - not just a literal. Moving it to an Integer makes DF EVALUATE it as a numeric
            // expression: that faults err 54 "Invalid symbol in expression" for a non-numeric symbol, and would
            // silently yield 0 even when it didn't fault (losing the position).
            Move TokenizerData.asLineTokens[iItem + 1] to sInPos
        End

        Move "" to sText
        If (sNose <> "") Begin
            Move sNose to sText
            Move (Trim(sText) + CS_S) to sText
        End
        Append sText CS_Move CS_S "(" CS_Insert "(" sVar1 "," sVar2 "," sInPos "))" " " CS_To CS_S sVar2

        Get AssembleOutputLine sText TokenizerData to sLine
        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Replaces IN command with expression operator Contains.
        It also swap places for the two variables involved and adds paranthesis.
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'In' to 'Contains' }
        """ }
    Function ChangeInToContains String ByRef sLine String sParameter Returns Boolean
        String sOrg sPattern sMatched sRemain sHost sSub sText sAfter sBefore sExpression
        Integer iSize iCount iItem
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End
        Move (SearchArray(CS_With, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Function_Return False
        End
        Move (SearchArray(CS_Insert, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Function_Return False
        End
        Move (SearchArray(CS_Pos, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Function_Return False
        End
        Move (SearchArray(CS_In, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem = -1) Begin
            Function_Return False
        End

        Move sLine to sOrg
        Move sLine to sText
        Move TokenizerData.asLineTokens[iItem -1] to sAfter
        Move TokenizerData.asLineTokens[iItem +1] to sBefore
        Decrement iItem
        Move ("(" + sBefore * CS_Contains * String(sAfter) + ")") to sExpression
        // Set the "Before" array item to the expression
        Move sExpression            to TokenizerData.asLineTokens[iItem]
        // Add expression to the expression array:
        Move (SizeOfArray(TokenizerData.aExpressions)) to iSize
        Move sExpression            to TokenizerData.aExpressions[iSize].sExpression
        Move (Length(sExpression))  to TokenizerData.aExpressions[iSize].iLength
        Move (Pos(sAfter, sOrg))    to TokenizerData.aExpressions[iSize].iStartPos
        If (TokenizerData.BooleanIndicator.AsBoolean.sCode <> "") Begin
            Move sExpression to TokenizerData.BooleanIndicator.AsBoolean.sCode
        End
        Increment iItem
        // Remove the two items we have concatenated.
        Move (RemoveFromArray(TokenizerData.asLineTokens, iItem)) to TokenizerData.asLineTokens
        Move (RemoveFromArray(TokenizerData.asLineTokens, iItem)) to TokenizerData.asLineTokens
        Move (SizeOfArray(TokenizerData.asLineTokens)) to TokenizerData.iTokenCount
        Get RebuildLineFromTokens TokenizerData.asLineTokens 0 to sText

        Set pTokenizer to TokenizerData
        If (sText <> sOrg) Begin
            Get AssembleOutputLine (Trim(sText)) TokenizerData to sLine
        End

        Function_Return (sLine <> sOrg)
    End_Function

// Text that was part of the Description, but was moved to here as it made the 
// Description meta-tag to large, leading to a compilation problem.
//        Not touched: `Find EQ <table>.<field>` (constant form), `-1` (recnum
//        mode), integer literals outside these contexts, comments, and string
//        literals (the tokenizer overlays string contents so they are immune),
//        and any line that does not reference the named table.
//
    { Published = True }
    { Description = """
        Changes index-number references in Find / vFind / Constrained_Find /
        Constrained_Clear / For_all commands from one index number to another,
        SCOPED to a specific table. Useful after a table-index restructure
        that renumbers indexes for one table.

        Rewrites BOTH `Index.<N>` and bare-integer forms in these positions:
            Find / Send Find / Get Find      : the <N> after a mode keyword
                                               (EQ, GT, LT, GE, LE, NE,
                                               FIRST, LAST, NEXT, PREV)
            vFind <tbl> <N> <mode>           : the 2nd argument after vFind
            Constrained_Find <mode> <tbl> by <N>
            Constrained_Clear <mode> <tbl> by <N>
            For_all <tbl> {by|down} <N>      : the <N> after by/down

        Table identification (case-insensitive):
            Direct token equal to the table name, OR
            DDO form: object named exactly `o<TableName>_DD` or
                      `o<TableName>_DataDictionary` (the two common
                      DataFlex conventions). Other DDO naming conventions
                      are NOT recognised - rewrite those manually.

        sParameter format: "<TableName>,<from>,<to>" - three comma-separated
        values; the table name and two positive (and unequal) integers.
        Example: "Customer,3,5".
        { MethodType = eStandardFunction }
        { EnumList = "ANY" }
        { SummaryText = Changed: index number in Find/Constrained/For_all commands }
        { ParamHelp = Three comma-separated values: the table name, the FROM
        \nindex number, and the TO index number. Example "Customer,3,5"
        \nchanges every Index.3 / by 3 / vFind Customer.X 3 ... reference
        \nfor the Customer table to use 5 instead. Both indexes must be
        \npositive (DataFlex indexes are 1-based; -1 = recnum mode, which
        \nis never modified). DDO form recognised: o<TableName>_DD and
        \no<TableName>_DataDictionary (case-insensitive). Other DDO
        \nnaming conventions need to be handled manually. }
        """ }
    Function ChangeIndexNumber String ByRef sLine String sParameter Returns Boolean
        String sOrgLine sFromStr sToStr sToken sTokenLC sRebuilt sNewLine sLineLC sMode
        String sKwLC sLineLCNow sNextChar sTableName sTableNameLC sRemainder
        Integer iFromIndex iToIndex iPos iPos2 iSize iItem iNext iCandidateIdx
        Integer iKwLen iSearchFrom iAbsPos iEndPos iPass
        Boolean bChanged bIsForAll bFoundContext bDone bRunPass bTableMatch
        tTokenizer TokenizerData

        // ---- Parse and validate sParameter (expect "<TableName>,<from>,<to>") ----
        Move (Trim(sParameter)) to sParameter
        Move (Pos(",", sParameter)) to iPos
        If (iPos = 0) ;
            Function_Return False
        Move (Trim(Left(sParameter, iPos - 1)))         to sTableName
        Move (Trim(Mid(sParameter, CI_EOL, iPos + 1))) to sRemainder
        Move (Pos(",", sRemainder)) to iPos2
        If (iPos2 = 0) ;
            Function_Return False
        Move (Trim(Left(sRemainder, iPos2 - 1)))         to sFromStr
        Move (Trim(Mid(sRemainder, CI_EOL, iPos2 + 1))) to sToStr
        If (sTableName = "") ;
            Function_Return False
        Move (Integer(sFromStr)) to iFromIndex
        Move (Integer(sToStr))   to iToIndex
        If (iFromIndex <= 0 or iToIndex <= 0 or iFromIndex = iToIndex) ;
            Function_Return False
        // Normalize back to canonical digit strings (strips any "+03" oddities).
        Move (String(iFromIndex)) to sFromStr
        Move (String(iToIndex))   to sToStr
        Move (Lowercase(sTableName)) to sTableNameLC

        // ---- Guard: skip blank/comment/image/in-command/variable-decl lines ----
        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        // ---- Quick line filter: must contain at least one of the five trigger
        //      keywords. Avoids accidentally renaming `Index.N` symbols in
        //      unrelated lines. Listed explicitly (vfind / constrained_find are
        //      technically redundant against `contains "find"` since "find" is a
        //      substring of both, but listed for clarity of intent). ----
        Move (Lowercase(TokenizerData.sOverstrikeLine)) to sLineLC
        If (not(sLineLC contains "find")             and ;
            not(sLineLC contains "vfind")            and ;
            not(sLineLC contains "constrained_find") and ;
            not(sLineLC contains "constrained_clear") and ;
            not(sLineLC contains "for_all")) Begin
            Function_Return False
        End

        // ---- Table scoping: line must reference sTableName as either a
        //      direct token OR via the DDO naming convention. ----
        Get _HasWordInLine sLineLC sTableNameLC to bTableMatch
        If (bTableMatch = False) Begin
            Get _HasWordInLine sLineLC ("o" + sTableNameLC + "_dd") to bTableMatch
        End
        If (bTableMatch = False) Begin
            Get _HasWordInLine sLineLC ("o" + sTableNameLC + "_datadictionary") to bTableMatch
        End
        If (bTableMatch = False) ;
            Function_Return False

        Move sLine to sOrgLine
        Move False to bChanged
        Move (SizeOfArray(TokenizerData.asLineTokens)) to iSize
        Decrement iSize
        If (iSize < 0) ;
            Function_Return False

        // ---- Walk tokens. Two independent checks per token: ----
        //   (a) Token IS `Index.<from>` -> rewrite digit, preserve "Index." case.
        //   (b) Token IS the leading keyword of a recognized context (Find /
        //       vFind / Constrained_Find / Constrained_Clear / For_all)
        //       whose index slot holds the bare integer <from>.
        For iItem from 0 to iSize
            Move TokenizerData.asLineTokens[iItem] to sToken
            Move (Lowercase(sToken)) to sTokenLC

            // (a) Index.<from>  ->  Index.<to>
            If (sTokenLC = ("index." + sFromStr)) Begin
                Move (Pos(".", sToken)) to iPos
                Move (Left(sToken, iPos) + sToStr) to TokenizerData.asLineTokens[iItem]
                Move True to bChanged
            End

            // (b1) Find (Send Find / Get Find / inline Find): walk forward to
            //      a mode keyword; the token after the mode is the index slot.
            If (sTokenLC = Lowercase(CS_Find)) Begin
                Move 0     to iCandidateIdx
                Move False to bFoundContext
                Move (iItem + 1) to iNext
                While (iNext <= iSize and bFoundContext = False)
                    Move (Lowercase(TokenizerData.asLineTokens[iNext])) to sMode
                    If (sMode = "eq"    or sMode = "gt"   or sMode = "lt"  or ;
                        sMode = "ge"    or sMode = "le"   or sMode = "ne"  or ;
                        sMode = "first" or sMode = "last" or ;
                        sMode = "next"  or sMode = "prev") Begin
                        Move True to bFoundContext
                        If ((iNext + 1) <= iSize) Move (iNext + 1) to iCandidateIdx
                    End
                    Increment iNext
                Loop
                If (iCandidateIdx > 0) Begin
                    If (TokenizerData.asLineTokens[iCandidateIdx] = sFromStr) Begin
                        Move sToStr to TokenizerData.asLineTokens[iCandidateIdx]
                        Move True to bChanged
                    End
                End
            End

            // (b2) vFind <tbl> <N> <mode>  -> index is exactly iItem+2.
            If (sTokenLC = "vfind") Begin
                If ((iItem + 2) <= iSize) Begin
                    If (TokenizerData.asLineTokens[iItem + 2] = sFromStr) Begin
                        Move sToStr to TokenizerData.asLineTokens[iItem + 2]
                        Move True to bChanged
                    End
                End
            End

            // (b3) Constrained_Find / Constrained_Clear / For_all
            //      -> walk forward for `by` (or `down` for For_all);
            //         the token after is the index slot. -1 (recnum) is
            //         never touched because the FROM check requires a
            //         positive integer match.
            If (sTokenLC = "constrained_find" or sTokenLC = "constrained_clear" or sTokenLC = "for_all") Begin
                Move (sTokenLC = "for_all") to bIsForAll
                Move 0     to iCandidateIdx
                Move False to bFoundContext
                Move (iItem + 1) to iNext
                While (iNext <= iSize and bFoundContext = False)
                    Move (Lowercase(TokenizerData.asLineTokens[iNext])) to sMode
                    If (sMode = "by" or (bIsForAll = True and sMode = "down")) Begin
                        Move True to bFoundContext
                        If ((iNext + 1) <= iSize) Move (iNext + 1) to iCandidateIdx
                    End
                    Increment iNext
                Loop
                If (iCandidateIdx > 0) Begin
                    If (TokenizerData.asLineTokens[iCandidateIdx] = sFromStr) Begin
                        Move sToStr to TokenizerData.asLineTokens[iCandidateIdx]
                        Move True to bChanged
                    End
                End
            End
        Loop

        // ---- Reassemble line if anything actually changed via tokens ----
        If (bChanged = True) Begin
            Get RebuildLineFromTokens TokenizerData.asLineTokens 0 to sRebuilt
            Get AssembleOutputLine sRebuilt TokenizerData to sNewLine
            If (sNewLine <> sOrgLine) Begin
                Move sNewLine to sLine
            End
        End

        // ---- Textual fallback for `by <from>` / `down <from>` patterns. ----
        // The framework tokenizer bundles legacy-operator expressions
        // (e.g. on "Constrained_Clear EQ MyTable by 3" the EQ-mode causes
        // "EQ MyTable by 3" to collapse into a single expression token),
        // so the per-token walk above can't see `by` as a separate token.
        // Find / vFind have a tokenizer-level exclusion so they aren't
        // bundled; Constrained_Find / Constrained_Clear / For_all don't.
        // We catch the missed cases here with a direct case-insensitive
        // search on sLine, only for lines that already passed the
        // Constrained_*/For_all line filter. Digit-boundary check on
        // the trailing char prevents `by 30` from matching `by 3`.
        If (sLineLC contains "constrained_find" or ;
            sLineLC contains "constrained_clear" or ;
            sLineLC contains "for_all") Begin
            // Two passes: " by " always, then " down " only for For_all lines.
            For iPass from 0 to 1
                If (iPass = 0) Begin
                    Move " by " to sKwLC
                    Move True to bRunPass
                End
                Else Begin
                    Move " down "                     to sKwLC
                    Move (sLineLC contains "for_all") to bRunPass
                End
                If (bRunPass = True) Begin
                    Move (Length(sKwLC)) to iKwLen
                    Move (Lowercase(sLine)) to sLineLCNow
                    Move 1 to iSearchFrom
                    Move False to bDone
                    While (iSearchFrom <= Length(sLineLCNow) and bDone = False)
                        Move (Pos(sKwLC + sFromStr, Mid(sLineLCNow, CI_EOL, iSearchFrom))) to iAbsPos
                        If (iAbsPos = 0) Begin
                            Move True to bDone
                        End
                        Else Begin
                            Move (iAbsPos + iSearchFrom - 1) to iAbsPos
                            Move (iAbsPos + iKwLen + Length(sFromStr)) to iEndPos
                            Move "" to sNextChar
                            If (iEndPos <= Length(sLine)) Move (Mid(sLine, 1, iEndPos)) to sNextChar
                            If (sNextChar = "" or not("0123456789" contains sNextChar)) Begin
                                Move (Left(sLine, iAbsPos + iKwLen - 1) + sToStr + Mid(sLine, CI_EOL, iEndPos)) to sLine
                                Move (Lowercase(sLine)) to sLineLCNow
                                Move (iAbsPos + iKwLen + Length(sToStr)) to iSearchFrom
                            End
                            Else Begin
                                Move (iAbsPos + 1) to iSearchFrom
                            End
                        End
                    Loop
                End
            Loop
        End

        Function_Return (sLine <> sOrgLine)
    End_Function

    { Published = True }
    { Description = """
        Adds the default '.pkg' file extension to a Use statement that lacks one.
        Example: Use cMyClass -> Use cMyClass.pkg
        Leaves Use statements that already carry an extension (.pkg, .vw, ...) untouched.
        { MethodType = eStandardFunction }
        { FnGroup = Cleanup }
        { SummaryText = Added '.pkg' extension to a Use statement }
        { ModRecipe = 4535 | file extension }
        """ }
    Function AddUseFileExtension String ByRef sLine String sParameter Returns Boolean
        Boolean bIsUse
        String sLC sFileName
        Integer iUsePos iStart iEnd

        Get _IsUseLine sLine to bIsUse
        If (bIsUse = False) ;
            Function_Return False
        // Locate the filename token - the word right after "Use ".
        Move (Lowercase(sLine)) to sLC
        Move (Pos("use ", sLC)) to iUsePos
        Move (iUsePos + 4) to iStart
        While (Mid(sLine, 1, iStart) = " ")
            Increment iStart
        Loop
        Move iStart to iEnd
        While (iEnd <= Length(sLine) and Mid(sLine, 1, iEnd) <> " ")
            Increment iEnd
        Loop
        Move (Mid(sLine, (iEnd - iStart), iStart)) to sFileName
        // Skip if there is no filename, or it already carries an extension.
        If ((sFileName = "") or (sFileName contains ".")) ;
            Function_Return False
        // Insert ".pkg" immediately after the filename; indent + trailing comment are preserved.
        Move (Left(sLine, (iEnd - 1)) + ".pkg" + Mid(sLine, CI_EOL, iEnd)) to sLine
        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Left command with Left.
        Example: Left sVar 5 to sLeft -> Move (Left(sVar, 5)) to sLeft
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Left' command to function: 'Left' }
        { ModRecipe = 4531 | command: Left }
        """ }
    Function ChangeLeftCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_Left to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Modernises a legacy global Indicator declaration to a Boolean global variable. DataFlex
        Indicator declarations are always GLOBAL, so the modern form is a Global_Variable Boolean.
        Example: Indicator User -> Global_Variable Boolean User
        Multiple names on one line are kept: Indicator A B C -> Global_Variable Boolean A B C
        Owns the "Indicator. Use Boolean" variant of 4538 (the DECLARATION). 4538 is a SHARED number:
        the "Indicate. Use Move command" + "...without parentheses" ([Found] usage) variants route to
        ChangeLegacyIndicators / ChangeSquareBracketsIndicators - hence the match-text on every 4538 tag.
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Indicator declaration -> Global_Variable Boolean }
        { ModRecipe = 4538 | Use Boolean }
        """ }
    Function ChangeIndicatorToBoolean String ByRef sLine String sParameter Returns Boolean
        tTokenizer TokenizerData
        Integer iPos
        Get pTokenizer to TokenizerData
        // Only a standalone global "Indicator <name> [more names]" declaration: the FIRST code token is
        // exactly "Indicator" and at least one name follows. The first-token gate ignores incidental
        // uses - "Move Indicator_State to x", a "Property Indicator ..." inside a class, comments, etc.
        If (TokenizerData.bIsInCommand = True or TokenizerData.bIsInImage = True) ;
            Function_Return False
        If (SizeOfArray(TokenizerData.asLineTokens) < 2) ;
            Function_Return False
        If (Lowercase(TokenizerData.asLineTokens[0]) <> "indicator") ;
            Function_Return False
        // Splice the leading "Indicator" keyword (9 chars, whole word) -> "Global_Variable Boolean";
        // the indentation, the name list, and any trailing comment after it are preserved verbatim.
        Get _FindKeywordPos sLine "Indicator" True 1 to iPos
        If (iPos = 0) ;
            Function_Return False
        Move (Left(sLine, (iPos - 1)) + "Global_Variable Boolean" + Mid(sLine, (Length(sLine) - iPos - 8), (iPos + 9))) to sLine
        Function_Return True
    End_Function

    // ChangeLegacyIndicators - limitations + extra examples (kept as // comments to keep the
    // {Description} under the meta-tag size limit; runtime Help reads the {Description} body only):
    //   - Handles at most two booleans within one square bracket, e.g. [Found Select].
    //   - Leaves the line unchanged if it contains a GROUP or ALL indicator directive.
    //   More examples:
    //   - [Select] Indicate Select as Windowindex Eq Fieldindex --> Move (WindowIndex = FieldIndex) to Select
    //   - [Found|Not Found|FindErr|Not FindErr] While   -> e.g. While (Not(Found))
    //   - [Found] Indicate Found as Invoice.CustNum eq Customer.Number -> If (Found) Move (Invoice.CustNum eq Customer.Number) to Found
    //   - If [Not Found] Reread hTable -> If (Not(Found)) Reread hTable
    { Published = True }
    { Description = """
        Changes legacy 'Indicate' to expression
        Paired with ChangeSquareBracketsIndicators: THIS function does the deep transform but
        deliberately skips lines containing Find/Send/Constrain - the sibling sweeps those up.
        Run both together; this one then reports the bulk of the changes.
        Examples:
        - Indicate Found as True --> Move True to Found
        - [Found] and [FindErr] indicator statements.
        - [Found| Command -> e.g. If Found Command
        - While [Not Found]   -> e.g. While (Not(Found))
        - [~Found] begin -> If (Not(Found)) Begin
        - [Found ~Found] Begin -> If (Found and Not(Found)) Begin
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: [Found] -> (Not(Found)) }
        { EnumList = "eLeaveSelect, eModernizeSelect" }
        { InitialValue = eLeaveSelect }
        { ModRecipe = 4538 | Use Move command }
        { ModRecipe = 4538 | without parentheses }
        { ParamHelp = eLeaveSelect keeps [SELECT] as-is (safe default). eModernizeSelect also needs AddUseOldFMACCommands selected (it defines the SELECT macro). }
        """ }
    Function ChangeLegacyIndicators String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged bStartBracket bHasBracket bIndicateStart bIfStart
        String sToken sOverstrikeLine sNot sTo sMove sIf sFirstCmd sSecondCmd sExpression sOrgLine sVarName sNewCode
        Integer iItem iSize iPos iLeftBracketNo iStart iEnd iBracketTokenCount
        Boolean bSkip bModernizeSelect
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End
        Get HasBracket TokenizerData.BooleanIndicator to bHasBracket
        If (TokenizerData.BooleanIndicator.bHasIndicateCommand = False and bHasBracket = False) Begin
            Function_Return False
        End

        // SELECT-handling gate. By default we respect CS_NonRefactorableIndicators and skip
        // lines whose indicator has no valid modern bare form, leaving the harmless [...]
        // warning - bare-ifying e.g. SELECT would turn that warning into a compile error.
        // The user opts in with eModernizeSelect when OldFMACCommands.pkg is in the build.
        // sParameter arrives as the enum NAME from the UI combo ("eModernizeSelect") or as
        // the numeric VALUE from tests - resolve via _ParameterIsEnum; a bare Move of the
        // name into the Integer enum left the gate at eLeaveSelect, so the opt-in never
        // worked from the UI (2026-06-10). NO num_arguments guard: it is unreliable here
        // (nested sends/dynamic engine dispatch can clobber it), and an omitted parameter
        // arrives as "" which _ParameterIsEnum already treats as no-match.
        Get _ParameterIsEnum sParameter "eModernizeSelect" eModernizeSelect to bModernizeSelect
        If (bModernizeSelect = False) Begin
            Get _IndicatorIsNonRefactorable TokenizerData to bSkip
            If (bSkip = True) ;
                Function_Return False
        End

        // Use sOverstrikeLine so string literal content cannot trigger a false-positive match.
        If (Lowercase(TokenizerData.sOverstrikeLine) contains (Lowercase(CS_Find) + CS_S) or ;
            Lowercase(TokenizerData.sOverstrikeLine) contains (Lowercase(CS_Send) + CS_S) or ;
            Lowercase(TokenizerData.sOverstrikeLine) contains (Lowercase(CS_Constrain) + CS_S)) Begin
            Function_Return False
        End

        Move (SearchArray("GROUP", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Function_Return False
        End
        Move (SearchArray("ALL", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Function_Return False
        End

        // A LEADING bracket indicator + an explicit If + an Indicate command on ONE line (e.g.
        // '[Found] If sResult ne "" Indicate Found as StatLog.Function_Name eq sData') is a 3-way compound
        // the plain Case logic below cannot compose (it mangled such lines into e.g.
        // "If Indicate (Found) to Found"). Build an explicit guarded block instead:
        //     If (<indicator> and (<if-condition>)) Begin
        //         Move (<indicate-expr>) to <indicate-target>
        //     End
        // _ComposeBracketIfIndicateBlock returns "" for shapes it will NOT touch (compound bracket, or the
        // rarer no-"as" Indicate) - those fall through unchanged (no corruption). Placed AFTER the SELECT /
        // Find-Send-Constrain / GROUP / ALL guards so those protections win. Each piece IS still supported
        // alone elsewhere: bracket+If (test 38), If+Indicate (test 37), If-condition-bracket+Indicate (test 6).
        // Indicate is detected via the overstrike line ("indicate " - strings are masked there, so it only
        // matches a real command), NOT BooleanIndicator.bHasIndicateCommand: that flag keys off asLineTokens,
        // which a PARENTHESISED If-condition leaves without a clean "Indicate" token, so it read False and the
        // line fell through to the half-done old path.
        If (SizeOfArray(TokenizerData.asLineTokens) > 0) Begin
            If (Left(TokenizerData.asLineTokens[0], 1) = "[" and ;
                TokenizerData.bHasIfCommand = True and ;
                (Lowercase(TokenizerData.sOverstrikeLine) contains (Lowercase(CS_Indicate) + CS_S))) Begin
                Get _ComposeBracketIfIndicateBlock TokenizerData to sNewCode
                If (sNewCode <> "") Begin
                    Move sNewCode to sLine
                    Function_Return True
                End
                Function_Return False
            End
        End

        // Note: a bare-ified [Select] (eModernizeSelect) needs 'Use OldFMACCommands.pkg' added at the top
        // of the file. That is the companion AddUseOldFMACCommands' job (an eOtherFunction run after this
        // line-by-line pass); it SCANS the rewritten file for the bare Select rather than relying on a
        // flag set here - the engine resets per-function state before it runs, so a flag could not survive.

        // Has If-statement?
        Move (TokenizerData.bHasIfCommand = True) to bIfStart
        If (bIfStart = True) Begin
            Move (SearchArray(CS_If, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
            If (iItem <> -1) Begin
                Move TokenizerData.asLineTokens[iItem] to sIf
            End
        End
        Else Begin
            Move CS_If to sIf
        End

        // Has Move-statement?
        Move (SearchArray(CS_Move, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Move TokenizerData.asLineTokens[iItem] to sMove
        End
        Else Begin
            Move CS_Move to sMove
        End
        Move TokenizerData.FirstLeftCommand.sCode  to sFirstCmd
        Move TokenizerData.SecondLeftCommand.sCode to sSecondCmd

        // Has To-statement?
        Move (SearchArray(CS_To, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Move TokenizerData.asLineTokens[iItem] to sTo
        End
        Else Begin
            Move CS_To to sTo
        End

        Move sLine to sOrgLine
        Move 0 to iItem
        Move TokenizerData.asLineTokens[iItem] to sToken
        // Starts with a indicator bracket?
        Move (Left(sToken, 1) = "[") to bStartBracket
        Move CS_Not to sNot

        // Get the "Not" keyword:
        If (TokenizerData.BooleanIndicator.FirstBoolean.bHasNot  = True or ;
            TokenizerData.BooleanIndicator.SecondBoolean.bHasNot = True or ;
            TokenizerData.BooleanIndicator.ToBoolean.bHasNot     = True or ;
            TokenizerData.BooleanIndicator.AsBoolean.bHasNot     = True) Begin
            Move (SearchArray("[not", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
            If (iItem = -1) Begin
                Move (Pos(("[" + CS_Tilde), TokenizerData.sLine)) to iItem
                If (iItem = 0) Begin
                    Move -1 to iItem
                End
                Else If (iItem > 0) Begin
                    Move -1 to iItem
                End
            End
            If (iItem <> -1) Begin
                Get ReplaceBrackets TokenizerData.asLineTokens[iItem] to sNot
            End
        End

        // Has an "Indicate" command?
        Move (SearchArray(CS_Indicate, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        Move (iItem <> -1) to bIndicateStart

        // Plain "If [indicator] <rest>" with NO Indicate command (e.g. "If [Found] Begin"): the
        // Case-based reconstruction further down rebuilds the line from the boolean pieces and drops
        // the trailing part, collapsing "If [Found] Begin" into just "If". Handle this case the SAME
        // surgical way ChangeSquareBracketsIndicators does - swap each [indicator] for its expression
        // IN PLACE so the rest of the line (the Begin / command / comment) survives untouched. Run
        // this BEFORE the sCode paren-wrapping below, so ConvertBracketIndicatorsToExpression sees the
        // RAW indicator tokens it expects (pre-wrapping them would double the parentheses). A line that
        // STARTS with a bracket is left to the bStartBracket sub (it parenthesises Move operands), and a
        // line that carries an Indicate command still needs the full rebuild below.
        If (bStartBracket = False and bIfStart = True and bIndicateStart = False) Begin
            Move 0 to iBracketTokenCount
            Move (SizeOfArray(TokenizerData.asLineTokens) - 1) to iSize
            For iItem from 0 to iSize
                If (Left(TokenizerData.asLineTokens[iItem], 1) = "[") Begin
                    Increment iBracketTokenCount
                End
            Loop
            Move TokenizerData.sOverstrikeLine to sOverstrikeLine
            Move 1 to iLeftBracketNo
            While (Pos("[", sOverstrikeLine) > 0 and iLeftBracketNo <= iBracketTokenCount)
                Move (Pos("[", sOverstrikeLine)) to iStart
                Move (Pos("]", sOverstrikeLine)) to iEnd
                Move (Mid(sOverstrikeLine, (iEnd - iStart - 1), (iStart + 1))) to sVarName
                Get ConvertBracketIndicatorsToExpression iLeftBracketNo TokenizerData to sExpression
                Increment iLeftBracketNo
                If (sVarName <> "") Begin
                    Move (Replace("[" + sVarName + "]", sOverstrikeLine, sExpression)) to sOverstrikeLine
                End
            Loop
            Get RestoreOverstrikeLineValues sOverstrikeLine TokenizerData to sOverstrikeLine
            Get AssembleOutputLine sOverstrikeLine TokenizerData to sLine
            Function_Return (sLine <> sOrgLine)
        End

        // Add "Not" operator and add paranthesis to boolean expressions/variables;
        If (TokenizerData.BooleanIndicator.FirstBoolean.bHasNot = True) Begin
            Move ("(" + sNot + "(" + TokenizerData.BooleanIndicator.FirstBoolean.sCode + "))") to TokenizerData.BooleanIndicator.FirstBoolean.sCode
        End
        Else If (TokenizerData.BooleanIndicator.FirstBoolean.sCode <> "" and Left(TokenizerData.BooleanIndicator.FirstBoolean.sCode, 1) <> "(") Begin
            Move ("(" + TokenizerData.BooleanIndicator.FirstBoolean.sCode + ")") to TokenizerData.BooleanIndicator.FirstBoolean.sCode
        End
        If (TokenizerData.BooleanIndicator.SecondBoolean.bHasNot = True) Begin
            Move ("(" + sNot + "(" + TokenizerData.BooleanIndicator.SecondBoolean.sCode + "))") to TokenizerData.BooleanIndicator.SecondBoolean.sCode
        End
        Else If (Left(TokenizerData.BooleanIndicator.SecondBoolean.sCode, 1) <> "(" and Right(TokenizerData.BooleanIndicator.SecondBoolean.sCode, 1) <> ")") Begin
            If (TokenizerData.BooleanIndicator.SecondBoolean.sCode <> "") Begin
                Move ("(" + TokenizerData.BooleanIndicator.SecondBoolean.sCode + ")") to TokenizerData.BooleanIndicator.SecondBoolean.sCode
            End
        End
        If (TokenizerData.BooleanIndicator.ToBoolean.bHasNot = True) Begin
            Move ("(" + sNot + "(" + TokenizerData.BooleanIndicator.ToBoolean.sCode + "))") to TokenizerData.BooleanIndicator.ToBoolean.sCode
        End
        If (Left(TokenizerData.BooleanIndicator.ToBoolean.sCode, 1) <> "(" and Right(TokenizerData.BooleanIndicator.ToBoolean.sCode, 1) <> ")") Begin
            If (TokenizerData.BooleanIndicator.ToBoolean.sCode <> "" and not(TokenizerData.BooleanIndicator.ToBoolean.sCode contains CS_S)) Begin
                Move ("(" + TokenizerData.BooleanIndicator.ToBoolean.sCode + ")") to TokenizerData.BooleanIndicator.ToBoolean.sCode
            End
        End
        If (TokenizerData.BooleanIndicator.AsBoolean.bHasNot = True) Begin
            Move ("(" + sNot + "(" + TokenizerData.BooleanIndicator.AsBoolean.sCode + "))") to TokenizerData.BooleanIndicator.AsBoolean.sCode
        End
        If (Left(TokenizerData.BooleanIndicator.AsBoolean.sCode, 1) <> "(" and Right(TokenizerData.BooleanIndicator.AsBoolean.sCode, 1) <> ")") Begin
            If (TokenizerData.BooleanIndicator.AsBoolean.sCode <> "") Begin
                Move ("(" + TokenizerData.BooleanIndicator.AsBoolean.sCode + ")") to TokenizerData.BooleanIndicator.AsBoolean.sCode
            End
        End

        Case Begin
            // This was too much code, so it was broken out to a helper-function (sub):
            Case (bStartBracket = True)
                Get _ChangeLegacyIndicators_Sub TokenizerData TokenizerData.sOverstrikeLine (&bChanged) to sOverstrikeLine
                Case Break

            // 'If [False] Indicate Select as Windowindex Eq Fieldindex // Comment'
            // 'If [not found] Move (Windowindex Eq Fieldindex) to Select // Comment'
            // 'If dDate LE '01/01/1984' Indicate ERROR_DATE True'
            Case (bIfStart = True)
                Move sIf to sOverstrikeLine
                Move TokenizerData.BooleanIndicator.FirstBoolean.sCode to sToken
                Get ReplaceParanthesis sToken to sToken
                Move (Pos(Lowercase(sToken), Lowercase(Trim(sLine)))) to iPos
                If (iPos < TokenizerData.SecondLeftCommand.iStartPos) Begin
                    Move TokenizerData.BooleanIndicator.SecondBoolean.sCode to sToken
                    Move (SearchArray(sToken, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
                    If (iItem = -1) Begin
                        Get ReplaceParanthesis sToken to sToken
                        Move (SearchArray(sToken, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
                    End
                    If (iItem <> -1) Begin
                        Increment iItem
                        If (iItem <= SizeOfArray(TokenizerData.asLineTokens)) Begin
                            Move TokenizerData.asLineTokens[iItem] to sToken
                            If (Lowercase(sToken) = Lowercase(CS_As)) Begin
                                Increment iItem
                                Move TokenizerData.asLineTokens[iItem] to sToken
                            End
                        End
                        If (Lowercase(sToken) = Lowercase(CS_To)) Begin
                            Increment iItem
                            Move TokenizerData.asLineTokens[iItem] to sToken
                            Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode CS_S sMove
                            Move TokenizerData.BooleanIndicator.SecondBoolean.sCode to sExpression
                            Append sOverstrikeLine CS_S sExpression CS_S sTo CS_S sToken
                        End
                        Else Begin
                            Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode CS_S sMove
                            Move TokenizerData.BooleanIndicator.SecondBoolean.sCode to sExpression
                            Get ReplaceParanthesis sExpression to sExpression
                            Append sOverstrikeLine CS_S sToken CS_S sTo CS_S sExpression
                        End
                    End
                End
                Else Begin
                    Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode
                    If (TokenizerData.BooleanIndicator.AsBoolean.sCode <> "") Begin
                        Append sOverstrikeLine CS_S sMove CS_S TokenizerData.BooleanIndicator.AsBoolean.sCode
                        Move TokenizerData.BooleanIndicator.SecondBoolean.sCode to sToken
                        Append sOverstrikeLine CS_S sTo   CS_S sToken
                    End
                    Else Begin
                        Append sOverstrikeLine CS_S sMove CS_S TokenizerData.BooleanIndicator.SecondBoolean.sCode
                        Move TokenizerData.BooleanIndicator.ToBoolean.sCode to sToken
                        Get ReplaceParanthesis sToken to sToken
                        Append sOverstrikeLine CS_S sTo   CS_S sToken
                    End
                End

                Case Break

            // 'Indicate Found as True'
            // 'Indicate [Found] as True'
            // 'Indicate Select as Windowindex Eq Fieldindex // Comment'
            Case (bIndicateStart = True)
                Move CS_Move to sOverstrikeLine
                If (Left(TokenizerData.BooleanIndicator.FirstBoolean.sCode, 1) = "(") Begin
                    Get ReplaceParanthesis TokenizerData.BooleanIndicator.FirstBoolean.sCode to TokenizerData.BooleanIndicator.FirstBoolean.sCode
                End
                // If AsBoolean.sCode = "" we have a missing "as" keyword on line, so we adjust for that here.
                If (TokenizerData.BooleanIndicator.AsBoolean.sCode = "") Begin
                    Move (SizeOfArray(TokenizerData.asLineTokens)) to iSize
                    Move TokenizerData.asLineTokens[iSize -1] to TokenizerData.BooleanIndicator.AsBoolean.sCode
                End
                If (TokenizerData.BooleanIndicator.AsBoolean.sCode <> "" and Left(TokenizerData.BooleanIndicator.AsBoolean.sCode, 1) <> "(") Begin
                    Move ("(" + TokenizerData.BooleanIndicator.AsBoolean.sCode +")") to TokenizerData.BooleanIndicator.AsBoolean.sCode
                End
                Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.AsBoolean.sCode CS_S CS_To CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode
                Case Break

            // Starts with any other than: "If", "Indicate" or a square bracket indicator as e.g. "[Not Found]". I.e. another command.
            Case Else
                // Do we have a e.g. "While [Not Found]" construct?
                If (Pos(sFirstCmd, TokenizerData.sOverstrikeLine) < Pos("[", TokenizerData.sOverstrikeLine)) Begin
                    Move sFirstCmd to sOverstrikeLine
                    Append sOverstrikeLine CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode
                End
                Else Begin
                    Move TokenizerData.BooleanIndicator.ToBoolean.sCode to sToken
                    If (sToken = "") Begin
                        Move TokenizerData.BooleanIndicator.AsBoolean.sCode to sToken
                    End
                    Move (CS_Move * String(sToken)) to sOverstrikeLine
                    If (SearchArray(sTo, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP)) <> -1) Begin
                        Append sOverstrikeLine CS_S sTo CS_S TokenizerData.BooleanIndicator.FirstBoolean.sCode
                    End
                    Else Begin
                        Move TokenizerData.asLineTokens[(SizeOfArray(TokenizerData.asLineTokens) -1)] to sToken
                        Move (SearchArray(CS_As, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
                        If (iItem <> -1) Begin
                            Move TokenizerData.BooleanIndicator.FirstBoolean.sCode to sToken
                            Append sOverstrikeLine CS_S sTo CS_S sToken
                        End
                        Else Begin
                            Append sOverstrikeLine CS_S sToken
                        End
                    End
                End
        Case End

        Get AssembleOutputLine sOverstrikeLine TokenizerData to sLine
        Function_Return (sLine <> sOrgLine)
    End_Function

    { Published = True }
    { Description = """
        Changes legacy comparison operators to: <, <=, =, <>, >, >=
        Replaces: gt, ge, lt, le, eq, ne with > >= < <= = <>
        It does not change operators in e.g. find operations.
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: lt, le, eq, ne, gt, ge to: <, <=, =, <>, >, >= }
        """ }
    Function ChangeLegacyOperators String ByRef sLine String sParameter Returns Boolean
        String sExpression sOrg sOrgNS sOverStrikeLine sChar sToken
        Boolean bFound bChanged bHasEndComment
        Integer iItem iPos iLeftParanthesis iRightParanthesis iToken iBodyIdx iTokenMax iSearch iNotPos iIdentEnd iIfPos
        String[] asCommands asScopeStart
        tTokenizer TokenizerData
        tOperatorsInfo OperatorInfo

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End
        If (TokenizerData.OperatorsInfo.bIsLegacy = False) Begin
            Function_Return False
        End
        If (Lowercase(TokenizerData.FirstLeftCommand.sCode) = Lowercase(CS_Find) or Lowercase(TokenizerData.SecondLeftCommand.sCode) = Lowercase(CS_Find)) Begin
            Function_Return False
        End
        Move (SearchArray(CS_Constrain, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Function_Return False
        End
        Get HasLegacyOperator TokenizerData.sOverstrikeLine to bFound
        If (bFound = False) Begin
            Function_Return False
        End

        Move (Ltrim(sLine)) to sOrg
        Get RebuildLineFromTokens TokenizerData.asLineTokens 0 to sOrgNS
        If (SizeOfArray(TokenizerData.aExpressions) <> 0) Begin
            Get ReplaceAllLegacyOperators sOrgNS to sOrgNS
        End

        // A compound If chain (e.g. "If (a = b) If c Eq 5 Begin") causes the expression
        // extractor to include the secondary "If" keyword inside the extracted expression.
        // "If" is illegal inside an expression and must be replaced with "and".
        // The pattern ") If " (closing paren + If) uniquely identifies a secondary "If"
        // inside an expression; "Else If" and the leading "If" command are not affected.
        Move (Replaces(") " + CS_If + CS_S, sOrgNS, ") and ")) to sOrgNS

        // The compiler rejects `If (a) and (b) Begin` and requires an outer pair of parens:
        // `If ((a) and (b)) Begin`. Walk the parenthesised sub-expressions joined by " and "
        // / " or " starting at the "If " keyword; if we found at least one such connector,
        // wrap the whole chain with outer parens.
        Move (Pos(CS_If + CS_S, sOrgNS)) to iPos
        If (iPos > 0) Begin
            Move (iPos + Length(CS_If) + 1) to iLeftParanthesis
            If (Mid(sOrgNS, 1, iLeftParanthesis) = "(") Begin
                Move iLeftParanthesis to iPos
                Move 0 to iRightParanthesis
                Move False to bFound
                Move False to bChanged
                While (bChanged = False)
                    Move (Mid(sOrgNS, 1, iPos)) to sChar
                    If (sChar <> "(") Begin
                        Move True to bChanged
                    End
                    Else Begin
                        Get _FindMatchingParentheses sOrgNS iPos to iRightParanthesis
                        If (Lowercase(Mid(sOrgNS, 6, iRightParanthesis + 1)) = " and (") Begin
                            Move True to bFound
                            Move (iRightParanthesis + 6) to iPos
                        End
                        Else If (Lowercase(Mid(sOrgNS, 5, iRightParanthesis + 1)) = " or (") Begin
                            Move True to bFound
                            Move (iRightParanthesis + 5) to iPos
                        End
                        Else If (Lowercase(Mid(sOrgNS, 5, iRightParanthesis + 1)) = " and " ;
                              or Lowercase(Mid(sOrgNS, 4, iRightParanthesis + 1)) = " or ") Begin
                            // Compound chain whose second sub-expression is NOT parenthesised
                            // (e.g. `If (X) and Not iType Set ...`). Use asLineTokens — still
                            // unchanged here — to locate the body command, then wrap up to the
                            // position just before that command.
                            // Note: iTokenMax / iSearch are kept SEPARATE from iItem because the
                            // For loop's `to` bound is re-evaluated each iteration, so reusing
                            // the bound variable for SearchArray results would terminate the loop
                            // prematurely the first time the result is -1.
                            Get pasCommands   to asCommands
                            Get pasScopeStart to asScopeStart
                            Move -1 to iBodyIdx
                            Move (SizeOfArray(TokenizerData.asLineTokens)) to iTokenMax
                            Decrement iTokenMax
                            For iToken from 1 to iTokenMax
                                Move TokenizerData.asLineTokens[iToken] to sToken
                                If (Lowercase(sToken) <> Lowercase(CS_If)) Begin
                                    Move (SearchArray(sToken, asCommands, Desktop, RefFunc(DFSTRICMP))) to iSearch
                                    If (iSearch = -1) Begin
                                        Move (SearchArray(sToken, asScopeStart, Desktop, RefFunc(DFSTRICMP))) to iSearch
                                    End
                                    If (iSearch <> -1) Begin
                                        Move iToken to iBodyIdx
                                        Move (iTokenMax + 1) to iToken   // jump out of For loop
                                    End
                                End
                            Loop
                            If (iBodyIdx > 0) Begin
                                Move TokenizerData.asLineTokens[iBodyIdx] to sToken
                                Move (Pos(CS_S + sToken + CS_S, sOrgNS)) to iItem
                                If (iItem = 0) Begin
                                    Move (Pos(CS_S + sToken, sOrgNS)) to iItem
                                End
                                If (iItem > iRightParanthesis) Begin
                                    // First, replace any remaining inner ` If ` with ` and ` in
                                    // the boolean range. The earlier `) If ` -> `) and ` Replaces
                                    // at line 1107 only catches Ifs that follow a `)`. A third
                                    // compound If (DataFlex allows up to 3 on one line) preceded
                                    // by a bare token, e.g. `If (a) If b If c body`, leaves the
                                    // third ` If ` in place — and the compiler rejects ` If ` once
                                    // we wrap the whole thing in outer parens. Case-insensitive so
                                    // " If "/" if "/" IF " all qualify.
                                    Move iLeftParanthesis to iIfPos
                                    Repeat
                                        Move 0 to iSearch
                                        If (iIfPos < iItem) Begin
                                            Move (Pos(" if ", Lowercase(Mid(sOrgNS, iItem - iIfPos, iIfPos)))) to iSearch
                                        End
                                        If (iSearch > 0) Begin
                                            Move (iIfPos + iSearch - 1) to iIfPos
                                            Move (Left(sOrgNS, iIfPos - 1) + " and " + Mid(sOrgNS, CI_EOL, iIfPos + 4)) to sOrgNS
                                            Increment iItem   // body shifted by the inserted char
                                            Move (iIfPos + 5) to iIfPos
                                        End
                                    Until (iSearch = 0)

                                    // Then transform `not <ident>` -> `not(<ident>)` in the boolean
                                    // range. DataFlex accepts `If Not X Begin` standalone, but
                                    // inside a parenthesised compound (`If ((Y) and Not X) Begin`)
                                    // the command-style `Not X` is rejected. Case-insensitive so
                                    // both " Not " and " not " are caught; the original case is
                                    // preserved in the output (just `(` and `)` inserted).
                                    Move iLeftParanthesis to iNotPos
                                    Repeat
                                        Move 0 to iSearch
                                        If (iNotPos < iItem) Begin
                                            Move (Pos(" not ", Lowercase(Mid(sOrgNS, iItem - iNotPos, iNotPos)))) to iSearch
                                        End
                                        If (iSearch > 0) Begin
                                            Move (iNotPos + iSearch - 1) to iNotPos
                                            If (Mid(sOrgNS, 1, iNotPos + 5) <> "(") Begin
                                                Move (iNotPos + 5) to iIdentEnd
                                                While (iIdentEnd <= Length(sOrgNS) and Mid(sOrgNS, 1, iIdentEnd) <> CS_S)
                                                    Increment iIdentEnd
                                                Loop
                                                Move (Left(sOrgNS, iNotPos + 3) + "(" + ;
                                                      Mid(sOrgNS, iIdentEnd - iNotPos - 5, iNotPos + 5) + ")" + ;
                                                      Mid(sOrgNS, CI_EOL, iIdentEnd)) to sOrgNS
                                                Increment iItem   // body shifted by the inserted ')'
                                                Move (iIdentEnd + 1) to iNotPos
                                            End
                                            Else Begin
                                                Move (iNotPos + 5) to iNotPos
                                            End
                                        End
                                    Until (iSearch = 0)

                                    Move (iItem - 1) to iRightParanthesis   // last char of boolean expr
                                    Move True to bFound
                                End
                            End
                            Move True to bChanged
                        End
                        Else Begin
                            Move True to bChanged
                        End
                    End
                Loop
                If (bFound = True) Begin
                    Move (Left(sOrgNS, iLeftParanthesis - 1) + ;
                          "(" + ;
                          Mid(sOrgNS, iRightParanthesis - iLeftParanthesis + 1, iLeftParanthesis) + ;
                          ")" + ;
                          Mid(sOrgNS, CI_EOL, iRightParanthesis + 1)) to sOrgNS
                End
            End
        End

        Move (TokenizerData.sIndentation + String(sOrgNS)) to sOrgNS
        If (sOrg <> sOrgNS) Begin
            Move sOrgNS to sLine
            If (TokenizerData.sEndComment <> "" and not(sLine contains TokenizerData.sEndComment)) Begin
                Append sLine CS_S TokenizerData.sEndComment
            End
        End
        Function_Return (sOrg <> sOrgNS)
    End_Function

    { Published = True }
    { Description = """
        Changes Shadow_State and Object_Shadow_State to Enabled_State
        Example: Set Shadow_State [of oObject] to True -> Set Enabled_State [of oObject] to False
                 Set Object_Shadow_State [of oObject] to True -> Set Enabled_State [of oObject] to False
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Shadow_State to Enabled_State }
        """ }
    Function ChangeLegacyShadow_State String ByRef sLine Returns Boolean
        String sToState sText sLineLC sEndComment sSpaces
        Boolean bFound
        Integer iPos
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Get IsKeywordInLine CS_Object_Shadow_State TokenizerData.asLineTokens to bFound
        If (bFound = False) Begin
            Get IsKeywordInLine CS_Shadow_State TokenizerData.asLineTokens to bFound
        End
        If (bFound = False) Begin
            Function_Return False
        End

        If (TokenizerData.sEndComment <> "") Begin
            Get EndComment sLine to sEndComment
            Move (Replace(sEndComment, sLine, "")) to sLine
            Move (Rtrim(sLine)) to sText
            Move (Replace(sText, sLine, "")) to sSpaces
            Move (sSpaces + String(sEndComment)) to sEndComment
            Move (Rtrim(sLine)) to sLine
        End

        Move (Lowercase(sLine)) to sLineLC
        Move (Pos(Lowercase(CS_Object_Shadow_State), sLineLC)) to iPos
        If (iPos <> 0) Begin
            Get ReplaceLineToken TokenizerData sLine CS_Object_Shadow_State CS_Enabled_State to sLine
        End
        Else Begin
            Move (Pos(Lowercase(CS_Shadow_State), sLineLC)) to iPos
            If (iPos <> 0) Begin
                Get ReplaceLineToken TokenizerData sLine CS_Shadow_State CS_Enabled_State to sLine
            End
        End
        Move (Lowercase(sLine)) to sLineLC

        // We also need to negate any "True" or "False" in the "to" part of the line
        Move TokenizerData.ToStatement.sCode to sToState
        If (Lowercase(sToState) = Lowercase(CS_True) or Lowercase(sToState) = Lowercase(CS_False)) Begin
            Get IsKeywordInLine CS_True TokenizerData.asLineTokens to bFound
            If (bFound = True) Begin
                Move (Pos(Lowercase(CS_True), sLineLC)) to iPos
                If (iPos <> 0) Begin
                    Get ReplaceLineToken TokenizerData sLine CS_True CS_False to sLine
                End
            End
            Else Begin
                Get IsKeywordInLine CS_False TokenizerData.asLineTokens to bFound
                Move (Pos(Lowercase(CS_False), sLineLC)) to iPos
                If (iPos <> 0) Begin
                    Get ReplaceLineToken TokenizerData sLine CS_False CS_True to sLine
                End
            End
        End
        // Or any self defined boolean variable at end of line:
        Else Begin
            Move (Pos(Lowercase(CS_Not), Lowercase(sToState))) to iPos
            // Add "not" keyword
            If (iPos = 0) Begin
                Move (Replace(sToState, sLine, ("(" + CS_Not + "(" + sToState + "))"))) to sLine
            End
            // Remove "not" keyword and its parantheses. Note that it can contain spaces.
            Else Begin
                Move (Replace("(", sToState, "")) to sText
                Move (Replace(Lowercase(CS_Not), sText, "")) to sText
                Move (Pos(Lowercase(CS_Not), Lowercase(sToState))) to iPos
                Move (Overstrike("   ", sToState, iPos)) to sToState
                Move (Replaces("(", sToState, "")) to sToState
                Move (Replaces(")", sToState, "")) to sToState
                Move (Trim(sToState))              to sToState
                Move (Pos(Lowercase(CS_S + CS_To + CS_S), sLineLC)) to iPos
                If (iPos <> 0) Begin
                    Move (Left(sLine, (iPos -1))) to sLine
                    Append sLine CS_S CS_To CS_S sToState
                End
            End
        End
        Move (Rtrim(sLine)) to sLine
        If (sEndComment <> "") Begin
            Append sLine sEndComment
        End
        Else If (TokenizerData.sEndComment <> "") Begin
            Append sLine CS_S TokenizerData.sEndComment
        End

        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Changes usage of the legacy Length command with function Length.
        Example: Length sVar to iLength -> Move (Length(sVar)) to iLength
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Length' command to function 'Length' }
        { ModRecipe = 4531 | command: Length }
        """ }
    Function ChangeLengthCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_Length to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes the obsolete Decr command to the modern Decrement command.
        Example: Decr iCount -> Decrement iCount
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Decr' command to 'Decrement' }
        { ModRecipe = 4533 | command: Decr }
        """ }
    Function ChangeDecrToDecrement String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get _SwapCommandKeyword (&sLine) "Decr" "Decrement" to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes the obsolete Incr command to the modern Increment command.
        Example: Incr iCount -> Increment iCount
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Incr' command to 'Increment' }
        { ModRecipe = 4533 | command: Incr }
        """ }
    Function ChangeIncrToIncrement String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get _SwapCommandKeyword (&sLine) "Incr" "Increment" to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes the obsolete Sub command to the modern Subtract command.
        Example: Sub iAmount to iTotal -> Subtract iAmount from iTotal
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Sub' command to 'Subtract' }
        { ModRecipe = 4533 | command: Sub }
        """ }
    Function ChangeSubToSubtract String ByRef sLine String sParameter Returns Boolean
        String sNose sArg1 sMid sArg2
        Integer iItem iPos
        tTokenizer TokenizerData
        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady or TokenizerData.bIsInCommand or ;
            TokenizerData.bIsInImage or TokenizerData.bIsVariableDeclaration) Begin
            Function_Return False
        End
        Move (SearchArray("Sub", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem = -1) ;
            Function_Return False
        // Legacy syntax is "Sub <value> to|from <variable>" -> needs 4 tokens from the keyword.
        If (SizeOfArray(TokenizerData.asLineTokens) < (iItem + 4)) ;
            Function_Return False
        Move TokenizerData.asLineTokens[iItem + 1] to sArg1
        Move TokenizerData.asLineTokens[iItem + 2] to sMid
        Move TokenizerData.asLineTokens[iItem + 3] to sArg2
        // The middle word MUST be "to" or "from", else this is not the legacy Sub command.
        If ((Lowercase(sMid) <> "to") and (Lowercase(sMid) <> "from")) ;
            Function_Return False
        // Locate the keyword boundary-aware on the MASKED line (position-
        // aligned with sLine) via _FindKeywordPos - a bare Pos("sub", ...)
        // matched INSIDE an earlier identifier (the "sub" in
        // "If (bSubmitted) Sub 1 from iCount") and spliced the line there
        // (2026-06-10 audit).
        Get _FindKeywordPos (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) "Sub" True 1 to iPos
        If (iPos = 0) ;
            Function_Return False
        // Keep the indent + any nose before the command; modern Subtract always uses "from".
        Move (Left(sLine, (iPos - 1))) to sNose
        Move (sNose + "Subtract " + sArg1 + " from " + sArg2) to sLine
        Function_Return True
    End_Function

    // Get_Argument_Size / Set_Argument_Size sized the legacy fixed string-argument buffer. Modern
    // DataFlex strings are dynamic, so both are no-ops - the compiler flags them obsolete (4533). The
    // usual idiom is save / enlarge / restore (Get_Argument_Size to v ... Set_Argument_Size n ...
    // Set_Argument_Size v); since all three are no-ops now, commenting them out is safe. We COMMENT
    // (not delete) so the change is visible and trivially reversible, and we match the keyword as a
    // whole TOKEN anywhere on the line, so an inline "If (cond) Set_Argument_Size n" / "Else ..." is
    // handled too. (After the save + restore are commented the saved-size local may go unused -
    // cosmetic; RemoveUnusedLocals clears it.) Categorised Review (eModSuggest), not Auto-fix: the
    // rare inline-If form drops the guarding If when the whole line is commented, so it's worth an eye.
    { Published = True }
    { Description = """
        Comments out the obsolete Get_Argument_Size / Set_Argument_Size commands (legacy string-buffer
        sizing; modern dynamic strings make them no-ops).
        Example: Set_Argument_Size 4096 -> // Set_Argument_Size 4096
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Commented out: Get_Argument_Size / Set_Argument_Size (obsolete) }
        { ModRecipe = 4533 | Set_Argument_Size | Suggest }
        { ModRecipe = 4533 | Get_Argument_Size | Suggest }
        """ }
    Function CommentOutArgumentSizeCommands String ByRef sLine String sParameter Returns Boolean
        Integer iItem
        tTokenizer TokenizerData
        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady or TokenizerData.bIsInCommand or ;
            TokenizerData.bIsInImage or TokenizerData.bIsVariableDeclaration) ;
            Function_Return False
        // Match either companion command as a whole token (case-insensitive), anywhere on the line - so
        // first-token, "If (cond) Set_Argument_Size n" and "Else Get_Argument_Size to v" all qualify. A
        // quoted string is a distinct token, so the keyword inside a literal/comment never false-matches.
        Move (SearchArray("Set_Argument_Size", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem = -1) ;
            Move (SearchArray("Get_Argument_Size", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem = -1) ;
            Function_Return False
        // Comment out the whole statement, preserving the original indentation.
        Move (TokenizerData.sIndentation + "// " + (Right(sLine, (Length(sLine) - Length(TokenizerData.sIndentation))))) to sLine
        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Mid command with function Mid.
        Example: Mid sText to sResult 5 3 -> Move (Mid(sText, 5, 3)) to sResult
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Mid' command to function 'Mid' }
        { ModRecipe = 4531 | command: Mid }
        """ }
    Function ChangeMidCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_Mid to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes usage of legacy Pos command with function Pos.
        Example: Pos "-"  in sIns to iPos --> Move (Pos("-",sIns)) to iPos
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Pos command to function Pos }
        { ModRecipe = 4531 | command: Pos }
        """ }
    Function ChangePosCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_Pos to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Replace command with function Replace.
        Example: Replace "," In sText With "." --> Move (Replace(",",sText,".")) to sText
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Replace command to function Replace }
        { ModRecipe = 4531 | command: Replace }
        """ }
    Function ChangeReplaceCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_Replace to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Right command with function Right
        Example: Right sVar 5 to sLeft -> Move (Rigth(sVar, 5)) to sLeft
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Right command to function }
        { ModRecipe = 4531 | command: Right }
        """ }
    Function ChangeRightCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_Right to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Character command with function Character.
        Example: Character 13 to CR -> Move (Character(13)) to CR
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Character' command to function 'Character' }
        { ModRecipe = 4531 | command: Character }
        """ }
    Function ChangeCharacterCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_Character to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Pad command with function Pad.
        Example: Pad sVar to sResult 20 -> Move (Pad(sVar, 20)) to sResult
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Pad' command to function 'Pad' }
        { ModRecipe = 4531 | command: Pad }
        """ }
    Function ChangePadCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_Pad to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Converts legacy Begin_Constraints / End_Constraints blocks into a modern OnConstrain procedure.
        The ENTIRE block body (declarations, Get/If/Else and the Constrains they control, and any
        Report_* lines) moves verbatim and in order into 'Procedure OnConstrain' (opened with 'Forward
        Send OnConstrain') - nothing is reordered or moved out, since e.g. a Report_Index parameter can
        depend on logic earlier in the block. Comments are kept, blank lines dropped. A block with no
        matching End_Constraints is left untouched. Takes a whole source file as a string array.
        { MethodType = eOtherFunction }
        { FnGroup = Modernization }
        { SummaryText = Refactored: Begin_Constraints -> OnConstrain }
        { ModRecipe = 4533 | command: Begin_Constraint }
        { ModRecipe = 4533 | command: End_Constraint }
        """ }
    Function ChangeBeginEndConstraint String[] ByRef asCode String sParameter Returns Integer
        String[] asOut asBody asBlockRaw asEmpty
        Integer iCount iSize iBlocks i iMax iPos
        String sLine sTrim sFirst sLow sIndent
        Boolean bInBlock

        Move 0 to iBlocks
        Move False to bInBlock
        Move (SizeOfArray(asCode)) to iSize
        Decrement iSize
        For iCount from 0 to iSize
            Move asCode[iCount] to sLine
            Move (Trim(sLine)) to sTrim
            // First whitespace-delimited token of the trimmed line.
            Move (Pos(" ", sTrim)) to iPos
            If (iPos > 0) Begin
                Move (Trim(Left(sTrim, (iPos - 1)))) to sFirst
            End
            Else Begin
                Move sTrim to sFirst
            End
            Move (Lowercase(sFirst)) to sLow

            If (bInBlock = False) Begin
                If ((sLow = "begin_constraints") or (sLow = "begin_constraint")) Begin
                    // Open a block: remember the Begin_Constraints indentation, reset the buffers.
                    Move True to bInBlock
                    Move (Pos(sTrim, sLine)) to iPos
                    If (iPos > 1) Begin
                        Move (Left(sLine, (iPos - 1))) to sIndent
                    End
                    Else Begin
                        Move "" to sIndent
                    End
                    Move asEmpty to asBody
                    Move asEmpty to asBlockRaw
                    Move sLine to asBlockRaw[0]
                    Increment iBlocks
                End
                Else Begin
                    Move sLine to asOut[SizeOfArray(asOut)]
                End
            End
            Else Begin
                Move sLine to asBlockRaw[SizeOfArray(asBlockRaw)]
                If ((sLow = "end_constraints") or (sLow = "end_constraint")) Begin
                    // The ENTIRE block body moves verbatim and IN ORDER into OnConstrain - conditional
                    // constraints (If/Else around Constrain), declarations, AND any Report_* lines stay
                    // exactly where they were. A Report_Index parameter can be set by logic earlier in
                    // the block, so it must NOT be moved out.
                    Move (sIndent + "Procedure OnConstrain") to asOut[SizeOfArray(asOut)]
                    Move (sIndent + "    Forward Send OnConstrain") to asOut[SizeOfArray(asOut)]
                    Move (SizeOfArray(asBody) - 1) to iMax
                    For i from 0 to iMax
                        Move asBody[i] to asOut[SizeOfArray(asOut)]
                    Loop
                    Move (sIndent + "End_Procedure") to asOut[SizeOfArray(asOut)]
                    Move False to bInBlock
                End
                Else If (sTrim <> "") Begin
                    Move sLine to asBody[SizeOfArray(asBody)]
                End
            End
        Loop

        // Unterminated block (no End_Constraints): restore its raw lines unchanged so nothing breaks.
        If (bInBlock = True) Begin
            Move (SizeOfArray(asBlockRaw) - 1) to iMax
            For i from 0 to iMax
                Move asBlockRaw[i] to asOut[SizeOfArray(asOut)]
            Loop
            Move (iBlocks - 1) to iBlocks
        End

        Move asOut to asCode
        Function_Return iBlocks
    End_Function

    // ChangeDfTimerTocTimer - migrates safe dfTimer objects only. An object is left UNCHANGED with a
    // //TODO comment (human judgment needed) when it relied on auto-start (no 'Set Auto_Start_State to
    // False'), uses the Timer_Message dispatch, or uses its OnTimer params in the body. The per-object
    // rules live in _MigrateDfTimerBlock (cRefactorFuncLib); this function finds the objects, applies it,
    // and renames Timer_Active_State -> pbEnabled file-wide.
    { Published = True }
    { Description = """
        Migrates legacy 'Object ... is a dfTimer' objects to the modern cTimer: swaps the class, drops
        Auto_Start_State/Auto_Stop_State/Timer_object, renames Timeout -> piTimeout, strips the OnTimer
        params, and renames Timer_Active_State -> pbEnabled file-wide. Objects that need human judgment
        are left unchanged, each marked with a //TODO comment. Takes a whole source file as a string array.
        { MethodType = eOtherFunction }
        { SummaryText = Migrated: dfTimer -> cTimer }
        { ModRecipe = 4537 | class: DFTIMER }
        { FnGroup = Modernization }
        """ }
    Function ChangeDfTimerTocTimer String[] ByRef asCode String sParameter Returns Integer
        String[] asOut asBlock asMigrated asEmpty
        String sLine sLow sT0 sReason sIndent
        Integer iCount iSize iMigrated i iMax iDepth iPos iN iFound
        Boolean bInBlock
        tTokenizer TD

        Move 0 to iMigrated
        Move False to bInBlock
        Move 0 to iDepth
        Move (SizeOfArray(asCode)) to iSize
        Decrement iSize
        For iCount from 0 to iSize
            // Per-file progress: nudge the status panel's bar every ~20 lines so the current file shows
            // progress during this whole-file pass (no-op in batch mode / the test runner, where the
            // panel isn't active). Mirrors cUnicodePointerToString.
            If (Mod(iCount, 20) = 0 and (Active_State(ghoStatusPanel) = True)) Begin
                Send Update_StatusPanel of ghoStatusPanel ("Source line:" * String(iCount + 1) * "of:" * String(iSize + 1))
                Set piPosition of ghoProgressBar to (iCount + 1)
            End
            Move asCode[iCount] to sLine
            // Timer_Active_State -> pbEnabled, file-wide (DFTimer-specific external on/off switch, so
            // safe everywhere). Done first so refs inside a timer object are covered too.
            Move (Lowercase(sLine)) to sLow
            Move (Pos("timer_active_state", sLow)) to iPos
            If (iPos > 0) ;
                Move (Left(sLine, (iPos - 1)) + "pbEnabled" + Mid(sLine, Length(sLine), (iPos + 18))) to sLine
            Get Tokenizer of Self sLine to TD
            Move (SizeOfArray(TD.asLineTokens)) to iN
            Move "" to sT0
            If (iN > 0) ;
                Move (Lowercase(TD.asLineTokens[0])) to sT0

            If (bInBlock = False) Begin
                Move (SearchArray("dfTimer", TD.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iFound
                If ((sT0 = "object") and (iFound > -1)) Begin
                    // Open a dfTimer object; remember its indentation for any //TODO flag line.
                    Move True to bInBlock
                    Move 1 to iDepth
                    Move asEmpty to asBlock
                    Move sLine to asBlock[0]
                    Move (Pos(Trim(sLine), sLine)) to iPos
                    If (iPos > 1) ;
                        Move (Left(sLine, (iPos - 1))) to sIndent
                    Else ;
                        Move "" to sIndent
                End
                Else Begin
                    Move sLine to asOut[SizeOfArray(asOut)]
                End
            End
            Else Begin
                Move sLine to asBlock[SizeOfArray(asBlock)]
                If (sT0 = "object") ;
                    Increment iDepth
                If (sT0 = "end_object") Begin
                    Decrement iDepth
                    If (iDepth = 0) Begin
                        Get _MigrateDfTimerBlock of Self asBlock (&sReason) to asMigrated
                        If (sReason <> "") Begin
                            // Not safe to auto-migrate - leave the object verbatim, flag it for a human.
                            Move (sIndent + "//TODO dfTimer->cTimer (skipped): " + sReason) to asOut[SizeOfArray(asOut)]
                            Move (SizeOfArray(asBlock) - 1) to iMax
                            For i from 0 to iMax
                                Move asBlock[i] to asOut[SizeOfArray(asOut)]
                            Loop
                        End
                        Else Begin
                            Move (SizeOfArray(asMigrated) - 1) to iMax
                            For i from 0 to iMax
                                Move asMigrated[i] to asOut[SizeOfArray(asOut)]
                            Loop
                            Increment iMigrated
                        End
                        Move False to bInBlock
                    End
                End
            End
        Loop

        // Unterminated object (no matching End_Object): flush the buffered lines unchanged.
        If (bInBlock = True) Begin
            Move (SizeOfArray(asBlock) - 1) to iMax
            For i from 0 to iMax
                Move asBlock[i] to asOut[SizeOfArray(asOut)]
            Loop
        End

        Move asOut to asCode
        Function_Return iMigrated
    End_Function

    // ChangeSquareBracketsIndicators - limitation + extra examples (kept as // to keep the
    // {Description} under the meta-tag size limit):
    //   - Leaves the line unchanged if it contains a GROUP or ALL indicator directive.
    //   More examples:
    //   - While [Not Found]   -> e.g. While (Not(Found))
    //   - [Not Found] While   -> e.g. While (Not(Found))
    //   - If [Not Found] Reread hTable -> If (Not(Found)) Reread hTable
    //   - [~Found] Begin -> If (Not(Found)) Begin
    //   - [Found ~Found] Begin -> If (Found and Not(Found)) Begin
    { Published = True }
    { Description = """
        Changes legacy square brackets found indicators; [Found] [FindErr] to expressions; (Found) or (Not(Found))
        It does not change the 'Indicate' key word, only change square brackets to expressions.
        Paired with ChangeLegacyIndicators, which runs first but skips lines containing
        Find/Send/Constrain - THIS function sweeps those up, so reporting few or zero
        changed lines is NORMAL when both are selected.
        Sample Code:
          - [Found] and [FindErr] indicator statements to (Found) and (FindErr).
          - [Found| Command -> e.g. If (Found) Command
          - [FindErr] Send Rebuild_constraints of oDD -> If (FindErr) Send Rebuild_constraints of oDD
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Square indicator expression [xxx] --> Paranthesis expression (xxx) }
        { EnumList = "eLeaveSelect, eModernizeSelect" }
        { InitialValue = eLeaveSelect }
        { ModRecipe = 4538 | without parentheses }
        { ParamHelp = eLeaveSelect keeps [SELECT] as-is (safe default). eModernizeSelect also needs AddUseOldFMACCommands selected (it defines the SELECT macro). }
        """ }
    Function ChangeSquareBracketsIndicators String ByRef sLine String sParameter Returns Boolean
        String sNewCode sVarName sExpression
        Boolean bFound bHasBracket bChanged
        Integer iStart iEnd iItem iLeftBracketNo iBracketTokenCount
        Boolean bSkip bModernizeSelect
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or;
            TokenizerData.bIsInCommand = True or;
            TokenizerData.bIsInStruct  = True or;
            TokenizerData.bIsInImage   = True or;
            TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End
        Get HasBracket TokenizerData.BooleanIndicator to bHasBracket
        If (bHasBracket = False) Begin
            Function_Return False
        End

        // See ChangeLegacyIndicators: a LEADING bracket + If + Indicate 3-way compound cannot be safely
        // modernised on one line - converting the leading bracket here would yield "If (Found) If sCustCode
        // ne "" Indicate ..." (double-If garbage). Leave it unchanged. A leading bracket is token[0]; the
        // supported "If [bool] Indicate ..." (test 6) has token[0] = "If" and is untouched by this guard.
        If (SizeOfArray(TokenizerData.asLineTokens) > 0) Begin
            If (Left(TokenizerData.asLineTokens[0], 1) = "[" and ;
                TokenizerData.bHasIfCommand = True and ;
                (Lowercase(TokenizerData.sOverstrikeLine) contains (Lowercase(CS_Indicate) + CS_S))) ;
                Function_Return False
        End
        // We leave compound square bracket expessions combined withe keywords: "GROUP" and "ALL" alone:
        Move (SearchArray("GROUP", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Function_Return False
        End
        Move (SearchArray("ALL", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) Begin
            Function_Return False
        End

        // SELECT-handling gate. By default we respect CS_NonRefactorableIndicators and skip
        // lines whose bracket indicator has no valid modern bare form, leaving the harmless
        // [...] warning. The user opts in with eModernizeSelect when OldFMACCommands.pkg is
        // in the build, where bare Select compiles.
        // sParameter arrives as the enum NAME from the UI combo ("eModernizeSelect") or as
        // the numeric VALUE from tests - resolve via _ParameterIsEnum; a bare Move of the
        // name into the Integer enum left the gate at eLeaveSelect, so the opt-in never
        // worked from the UI (2026-06-10). NO num_arguments guard: it is unreliable here
        // (nested sends/dynamic engine dispatch can clobber it), and an omitted parameter
        // arrives as "" which _ParameterIsEnum already treats as no-match.
        Get _ParameterIsEnum sParameter "eModernizeSelect" eModernizeSelect to bModernizeSelect
        If (bModernizeSelect = False) Begin
            Get _IndicatorIsNonRefactorable TokenizerData to bSkip
            If (bSkip = True) ;
                Function_Return False
        End

        // Note: a bare-ified [Select] (eModernizeSelect) needs 'Use OldFMACCommands.pkg' added at the top
        // of the file - the companion AddUseOldFMACCommands (an eOtherFunction) does that by SCANNING the
        // rewritten file for the bare Select, so nothing needs to be flagged from here.

        // Count the genuine bracket indicator tokens in asLineTokens.
        // The tokeniser replaces parenthesised expressions with | pipes in asLineTokens,
        // so brackets that appear INSIDE a paren expression (e.g. an array index like
        // daPeriodDates[0]) are absent from asLineTokens.  Without this cap the while
        // loop below would use sOverstrikeLine — which does NOT mask paren content —
        // and would incorrectly treat array-index brackets as indicator brackets.
        Move 0 to iBracketTokenCount
        For iStart from 0 to (SizeOfArray(TokenizerData.asLineTokens) - 1)
            If (Left(TokenizerData.asLineTokens[iStart], 1) = "[") Begin
                Increment iBracketTokenCount
            End
        Loop

        Move TokenizerData.sOverstrikeLine to sNewCode
        Move 1 to iLeftBracketNo

        While (Pos("[", sNewCode) > 0 and iLeftBracketNo <= iBracketTokenCount)

            Move (Pos("[", sNewCode)) to iStart
            Move (Pos("]", sNewCode)) to iEnd
            Move (Mid(sNewCode, (iEnd - iStart -1), (iStart +1))) to sVarName
            // Convert bracketed indicators variables to an expression
            Get ConvertBracketIndicatorsToExpression iLeftBracketNo TokenizerData to sExpression
            Increment iLeftBracketNo

            // Handle negation cases
            If (sVarName <> "") Begin
                Move (Replace("[" + sVarName + "]", sNewCode, sExpression)) to sNewCode
            End
        Loop

        Get FixIndicatorsLoopRepeatCommand sNewCode to sNewCode
        // If the old expression started with a bracket, insert an "If" statement at start of line.
        If (Left(Trim(sNewCode), 1) = "(") Begin
            Move ("If" * String(sNewCode)) to sNewCode
        End

        Get RestoreOverstrikeLineValues sNewCode TokenizerData to sNewCode
        Get AssembleOutputLine sNewCode TokenizerData to sNewCode
        Move (sNewCode <> sLine) to bChanged
        Move sNewCode to sLine

        Function_Return bChanged
    End_Function

    // AddUseOldFMACCommands - the file-level companion to ChangeLegacyIndicators /
    // ChangeSquareBracketsIndicators. Those two (eStandardFunction, one line at a time) cannot add a
    // top-of-file definition themselves; under eModernizeSelect they bare-ify the legacy [Select] macro
    // indicator (e.g. [Select] -> (Select), Indicate Select as X -> Move (X) to Select). Bare SELECT only
    // compiles where the SELECT macro is defined.
    //
    // This eOtherFunction runs AFTER the line-by-line pass on the SAME file (see cRefactorEngine), so by
    // the time it sees asCode the legacy [Select] has ALREADY become the modern bare Select - there is no
    // [Select] left to look for. It therefore SCANS the rewritten code for a bare, boundary-aware
    // 'Select' token in real code and, when found, splices a guarded SELECT-macro definition near the top:
    //     #IFNDEF SELECT
    //         #Replace SELECT |!C
    //     #ENDIF
    // - the SAME definition the legacy REPORT command macro uses. It does NOT add 'Use OldFMACCommands.pkg':
    // that only makes the REPORT macro available, and OldFMACCommands.pkg defines SELECT ONLY if REPORT is
    // actually invoked - so a (Select) in a REPORT-less file would still fail to compile (the bug Nils hit).
    // The IFNDEF guard makes the shim idempotent AND conflict-free: a no-op in a file that already defines
    // SELECT (e.g. one that does use REPORT). The scan is the trigger - a per-file flag cannot be, because
    // the engine sends ClearFuncLibProperties before EVERY eOtherFunction (it would wipe any flag the
    // indicators raised during the line-by-line pass). Reading the final text also means it works when the
    // indicators were run in an earlier, separate run.
    //
    // String/comment safety: the scan reads the MASKED line (string literals overstruck) and skips
    // comment, blank, image and multi-line-string lines, so a SQL 'SELECT' inside a "..." literal or an
    // @SQL"""...""" / ; -continuation block can never trigger it; the word-boundary match also excludes
    // Selected / Select_State / Selection. Idempotent (skips a file that already has a #Replace SELECT),
    // and a no-op when no bare Select is present.
    { Published = True }
    { Description = """
        Defines the bare 'Select' macro indicator left behind when ChangeLegacyIndicators /
        ChangeSquareBracketsIndicators modernise a legacy [Select] under eModernizeSelect. Splices a guarded
        SELECT-macro definition near the top of the file (an IFNDEF-guarded Replace) - NOT a Use line, since
        OldFMACCommands.pkg defines SELECT only via the REPORT macro. Scans the rewritten code for a bare
        Select, string/comment-safe; run it with those two, or after. No-op when none is found or the
        definition is already present.
        { MethodType = eOtherFunction }
        { FnGroup = Modernization }
        { SummaryText = Defined: SELECT macro }
        { ModRecipe = 4345 | SELECT, MUST BE DEFINED }
        """ }
    Function AddUseOldFMACCommands String[] ByRef asCode String sParameter Returns Integer
        String[] asOut asShim
        String sLine sLC
        Integer iCount iSize iInsertAt iLastUse iFirstCode iSelectPos iShim
        Boolean bNeeds bAlreadyDefined bSeenCode bIsUseOrInc bInserted bSkipLine
        tTokenizer TD

        Move (SizeOfArray(asCode) - 1) to iSize
        If (iSize < 0) ;
            Function_Return 0

        Move False to bNeeds
        Move False to bAlreadyDefined
        Move False to bSeenCode
        Move -1 to iLastUse
        Move -1 to iFirstCode

        // ONE ordered pass (tokeniser is stateful, so top-to-bottom): detect the modernised bare Select
        // indicator (the reason to define the macro), note an existing '#Replace SELECT' definition, and
        // locate the top-of-file insertion point - after the leading Use/#include block, else before the
        // first real code line (so the macro precedes every use, and never lands inside a header comment).
        For iCount from 0 to iSize
            // Per-file progress nudge; no-op when no panel is active. Mirrors ChangeDfTimerTocTimer.
            If (Mod(iCount, 20) = 0 and (Active_State(ghoStatusPanel) = True)) Begin
                Send Update_StatusPanel of ghoStatusPanel ("Source line:" * String(iCount + 1) * "of:" * String(iSize + 1))
                Set piPosition of ghoProgressBar to (iCount + 1)
            End
            Move asCode[iCount] to sLine
            Get Tokenizer of Self sLine to TD

            // An existing '#Replace SELECT ...' directive (our prior shim, or a hand-written define) means
            // SELECT is already defined in-source -> nothing to add. A REPORT-using file has NO such line
            // in its source (REPORT defines SELECT inside the macro), so we still add the guarded shim,
            // which the IFNDEF then makes a no-op at compile time. (Note: 'Use OldFMACCommands.pkg' is NOT
            // a marker - it does not define SELECT on its own, so a file with only that line still needs us.)
            Move (Lowercase(Trim(sLine))) to sLC
            If ((Left(sLC, 8) = "#replace") and (sLC contains "select")) ;
                Move True to bAlreadyDefined

            // Detect the modernised bare Select indicator. Skip lines that are NOT real code - comment,
            // blank, image page, or part of a multi-line string (the latter is where a multi-line SQL
            // SELECT lives, per tTokenizer.bIsInDF23MultiLineString) - so such a 'SELECT' never triggers.
            // On the remaining code lines, search the MASKED line (indentation + overstrike, position-
            // aligned, with string literals blanked) boundary-aware: (Select) / Not(Select) / "to Select"
            // all match, while Selected / Select_State / Selection and a 'SELECT' inside a "..." literal
            // do not. Stop searching once found.
            Move (TD.bIsComment = True or TD.bIsBlank = True or TD.bIsInImage = True or TD.bIsInDF23MultiLineString = True) to bSkipLine
            If (bNeeds = False and bSkipLine = False) Begin
                Get _FindKeywordPos (TD.sIndentation + TD.sOverstrikeLine) CS_Select True 1 to iSelectPos
                If (iSelectPos > 0) ;
                    Move True to bNeeds
            End

            If (bSeenCode = False) Begin
                Get _IsUseOrIncludeLine sLine to bIsUseOrInc
                If (bIsUseOrInc = True) Begin
                    Move iCount to iLastUse
                End
                Else If (TD.bIsComment = False and TD.bIsBlank = False) Begin
                    Move iCount to iFirstCode
                    Move True to bSeenCode
                End
            End
        Loop

        // No bare Select anywhere -> nothing to do. Already defined -> idempotent no-op.
        If (bNeeds = False) ;
            Function_Return 0
        If (bAlreadyDefined = True) ;
            Function_Return 0

        // The guarded SELECT-macro shim to splice in: a // comment + the IFNDEF/Replace/ENDIF block. The
        // IFNDEF guard makes it idempotent and conflict-free (a no-op in a file that already defines SELECT,
        // e.g. one using REPORT). This REPLACES the old 'Use OldFMACCommands.pkg' line, which only made
        // REPORT available and did NOT define bare SELECT on its own. The #Replace line comes from
        // CS_SelectMacroDefineLine - its |!C is built from Character() codes because |!C is a compile-time
        // counter that a literal "|!C" in our source would evaluate here instead of emitting verbatim.
        Move "// SELECT macro defined by DFRefactor (OldFMACCommands.pkg defines it only via REPORT); IFNDEF-guarded, a no-op if already defined." to asShim[0]
        Move "#IFNDEF SELECT"        to asShim[1]
        Move CS_SelectMacroDefineLine to asShim[2]
        Move "#ENDIF"                to asShim[3]

        // Splice point: after the last leading Use/#include; else before the first code line; else top -
        // always before the first real code, so the #Replace precedes every (Select) use.
        If (iLastUse >= 0) ;
            Move (iLastUse + 1) to iInsertAt
        Else If (iFirstCode >= 0) ;
            Move iFirstCode to iInsertAt
        Else ;
            Move 0 to iInsertAt

        Move False to bInserted
        For iCount from 0 to iSize
            If (iCount = iInsertAt) Begin
                For iShim from 0 to (SizeOfArray(asShim) - 1)
                    Move asShim[iShim] to asOut[SizeOfArray(asOut)]
                Loop
                Move True to bInserted
            End
            Move asCode[iCount] to asOut[SizeOfArray(asOut)]
        Loop
        // Insertion point past the last line (all-preamble file): append the shim.
        If (bInserted = False) Begin
            For iShim from 0 to (SizeOfArray(asShim) - 1)
                Move asShim[iShim] to asOut[SizeOfArray(asOut)]
            Loop
        End

        Move asOut to asCode
        Function_Return 1
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Sysdate4 command to Sysdate command.
        Example: Sysdate4 dDate -> Sysdate dDate
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Sysdate4 command to Sysdate }
        { ModRecipe = 4533 | command: Sysdate4 }
        """ }
    Function ChangeSysdate4 String ByRef sLine String sParameter Returns Boolean
        Boolean bFound
        Integer iPos
        tTokenizer TokenizerData
        tToken Token

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Move TokenizerData.FirstLeftCommand to Token
        Move (Lowercase(Token.sCode) = Lowercase(CS_Sysdate4)) to bFound
        If (bFound = False) Begin
            Move TokenizerData.SecondLeftCommand to Token
            Move (Lowercase(Token.sCode) = Lowercase(CS_Sysdate4)) to bFound
            If (bFound = False) Begin
                Function_Return False
            End
        End

        // Remove the keyword's OWN trailing "4" positionally - a bare
        // Replace("4", ...) eats the FIRST "4" anywhere on the line (a "4"
        // in a variable or expression before the command; 2026-06-10 audit).
        // Locate the keyword boundary-aware on the MASKED line (position-
        // aligned with sLine) and splice that exact character out.
        Get _FindKeywordPos (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) CS_Sysdate4 True 1 to iPos
        If (iPos = 0) ;
            Function_Return False
        Move (Left(sLine, (iPos + Length(CS_Sysdate4) - 2)) + Mid(sLine, CI_EOL, (iPos + Length(CS_Sysdate4)))) to sLine
        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Changes lecacy Trim command with function Trim.
        Example: Trim sVal to sVal -> Move (Trim(sVal)) to sVal
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Trim command to function Trim }
        { ModRecipe = 4531 | command: Trim }
        """ }
    Function ChangeTrimCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bFound
        Integer iPos iStart iTrimPos iArgStart iArgEnd iToPos
        tTokenizer TokenizerData
        String sOverFull sCh

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Get IsKeywordInLine CS_Trim TokenizerData.asLineTokens to bFound
        If (bFound = False) Begin
            Function_Return False
        End

        // Work on the MASKED line (indentation + overstrike) - position-aligned with sLine,
        // with string content hidden, so a "Trim"/"to" inside a literal can never match.
        Move (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) to sOverFull

        // Locate the legacy Trim COMMAND: a boundary-aware "Trim" FOLLOWED BY WHITESPACE.
        // A "Trim(" function call has "(" right after the name, so it is never taken as the
        // command - that is what keeps a Trim(...) call on the same line untouched.
        Move 1 to iStart
        Move 0 to iTrimPos
        While (iTrimPos = 0)
            Get _FindKeywordPos sOverFull CS_Trim True iStart to iPos
            If (iPos = 0) ;
                Function_Return False
            Move (Mid(sOverFull, 1, (iPos + Length(CS_Trim)))) to sCh
            If (sCh = CS_S or sCh = Character(9)) ;
                Move iPos to iTrimPos
            Else ;
                Move (iPos + 1) to iStart
        Loop

        // Argument = the RAW text from the first non-blank after "Trim" up to the command
        // "to". Extracting by POSITION (not asLineTokens[next]) captures ANY argument shape -
        // a simple var, a table.field (USER.SPRAK), or a parenthesised expression
        // (Trim (Val(hDD,"X")) to y). The old single-token grab missed the paren form and
        // corrupted the dotted form into "Move (Trim(USER)).SPRAK" (Nils 2026-06-11).
        Move (iTrimPos + Length(CS_Trim)) to iArgStart
        While (iArgStart <= Length(sOverFull) and (Mid(sOverFull, 1, iArgStart) = CS_S or Mid(sOverFull, 1, iArgStart) = Character(9)))
            Increment iArgStart
        Loop

        Get _FindKeywordPos sOverFull CS_To True iArgStart to iToPos
        If (iToPos = 0 or iToPos <= iArgStart) ;
            Function_Return False

        // Last non-blank before "to" = the argument's end; the gap before "to" is kept verbatim.
        Move (iToPos - 1) to iArgEnd
        While (iArgEnd >= iArgStart and (Mid(sOverFull, 1, iArgEnd) = CS_S or Mid(sOverFull, 1, iArgEnd) = Character(9)))
            Decrement iArgEnd
        Loop
        If (iArgEnd < iArgStart) ;
            Function_Return False

        // Rebuild on the RAW line: <indent/nose> + Move (Trim(<arg>)) + <original gap> to <dest>.
        Move (Left(sLine, (iTrimPos - 1)) + CS_Move + " (" + CS_Trim + "(" + Mid(sLine, (iArgEnd - iArgStart + 1), iArgStart) + "))" + Mid(sLine, CI_EOL, (iArgEnd + 1))) to sLine
        Function_Return True
    End_Function

    // Generic "<Cmd> <arg> to <dest>" -> "Move (<Cmd>(<arg>)) to <dest>" rewrite for a single-argument
    // legacy string command (Uppercase, Lowercase, ...). Same robust approach as ChangeTrimCommandToFunction,
    // generalised by the keyword: the argument is extracted by POSITION (raw text from after the command
    // keyword up to the command "to"), so any shape survives - a simple var, a table.field (USER.SPRAK),
    // or a parenthesised expression. A "<Cmd>(" function CALL is left untouched (the keyword must be
    // FOLLOWED BY WHITESPACE, not "("). Requires an explicit "to <dest>".
    Function _SingleArgCommandToFunction String ByRef sLine String sKeyWord Returns Boolean
        Boolean bFound
        Integer iPos iStart iCmdPos iArgStart iArgEnd iToPos
        tTokenizer TokenizerData
        String sOverFull sCh

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Get IsKeywordInLine sKeyWord TokenizerData.asLineTokens to bFound
        If (bFound = False) Begin
            Function_Return False
        End

        // Work on the MASKED line (indentation + overstrike) - position-aligned with sLine, string
        // content hidden, so a keyword/"to" inside a literal can never match.
        Move (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) to sOverFull

        // Locate the legacy COMMAND: a boundary-aware keyword FOLLOWED BY WHITESPACE (a "<Cmd>(" call
        // has "(" right after the name, so it is never taken as the command - keeps a call untouched).
        Move 1 to iStart
        Move 0 to iCmdPos
        While (iCmdPos = 0)
            Get _FindKeywordPos sOverFull sKeyWord True iStart to iPos
            If (iPos = 0) ;
                Function_Return False
            Move (Mid(sOverFull, 1, (iPos + Length(sKeyWord)))) to sCh
            If (sCh = CS_S or sCh = Character(9)) ;
                Move iPos to iCmdPos
            Else ;
                Move (iPos + 1) to iStart
        Loop

        // Argument = RAW text from the first non-blank after the keyword up to the command "to".
        Move (iCmdPos + Length(sKeyWord)) to iArgStart
        While (iArgStart <= Length(sOverFull) and (Mid(sOverFull, 1, iArgStart) = CS_S or Mid(sOverFull, 1, iArgStart) = Character(9)))
            Increment iArgStart
        Loop

        Get _FindKeywordPos sOverFull CS_To True iArgStart to iToPos
        If (iToPos = 0 or iToPos <= iArgStart) ;
            Function_Return False

        // Last non-blank before "to" = the argument's end; the gap before "to" is kept verbatim.
        Move (iToPos - 1) to iArgEnd
        While (iArgEnd >= iArgStart and (Mid(sOverFull, 1, iArgEnd) = CS_S or Mid(sOverFull, 1, iArgEnd) = Character(9)))
            Decrement iArgEnd
        Loop
        If (iArgEnd < iArgStart) ;
            Function_Return False

        // Rebuild on the RAW line: <indent/nose> + Move (<Cmd>(<arg>)) + <original gap> to <dest>.
        Move (Left(sLine, (iCmdPos - 1)) + CS_Move + " (" + sKeyWord + "(" + Mid(sLine, (iArgEnd - iArgStart + 1), iArgStart) + "))" + Mid(sLine, CI_EOL, (iArgEnd + 1))) to sLine
        Function_Return True
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Uppercase command to the Uppercase function.
        Example: Uppercase sVal to sVal -> Move (Uppercase(sVal)) to sVal
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Uppercase command to function Uppercase }
        { ModRecipe = 4531 | command: Uppercase }
        """ }
    Function ChangeUppercaseCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get _SingleArgCommandToFunction (&sLine) CS_Uppercase to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Lowercase command to the Lowercase function.
        Example: Lowercase sVal to sVal -> Move (Lowercase(sVal)) to sVal
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: Lowercase command to function Lowercase }
        { ModRecipe = 4531 | command: Lowercase }
        """ }
    Function ChangeLowercaseCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get _SingleArgCommandToFunction (&sLine) CS_Lowercase to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy Get Create U_Class to: Get Create (RefClass(Class))
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: 'Create U_Class' to 'Create (RefClass(Class))' }
        """ }
    Function ChangeUClassToRefClass String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged bValid bIgnore
        String sTest sClassName sOldStyle sNewStyle
        Integer iPos
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End
        Move False to bChanged
        Move "" to sClassName
        Move (Lowercase(sLine)) to sTest
        Move (Replaces(Character(9), sTest, CS_S)) to sTest // tab
        Get TrimInsideSpaces sTest to sTest
        // Two lines which are mostly for protection when running DfRefactor on the DfRefactor code itself
        Get _RemoveEndComment sTest to sTest                // Don't rewrite this in a comment
        Get RemoveStringsFromLine sTest to sTest            // If this is in a string then obviously leave it alone too
        If (Pos(" create u_", sTest)) Begin
            Move (Lowercase(sLine)) to sTest
            // Locate the U_ class token on the MASKED line (position-aligned
            // with sLine) with a LEFT boundary only - "u_" is a PREFIX, so
            // bWholeWord is False. A bare Pos could land inside an earlier
            // identifier ("hU_x") or a string literal and rewrite the wrong
            // text (2026-06-10 audit).
            Get _FindKeywordPos (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) "u_" False 1 to iPos
            Get IsValidClassCharacter sTest iPos to bValid
            While (bValid)
                Move (sClassName + Mid(sLine, 1, iPos)) to sClassName
                Increment iPos
                Get IsValidClassCharacter sTest iPos to bValid
            Loop
        End
        If (sClassName <> "") Begin
            Move True to bChanged
            Move sClassName to sOldStyle
            Move (Right(sClassName, Length(sClassName) - 2)) to sClassName // strip away the "U_"
            Move ("(RefClass(" + sClassName + "))") to sNewStyle
            Move (Replace(sOldStyle, sLine, sNewStyle)) to sLine
        End
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Changes legacy ZeroString command with function ZeroString.
        Example: ZeroString iLength to sParameter --> Move (ZeroString(iLength)) to sParameter
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: ZeroString command to function }
        { ModRecipe = 4532 | ZeroString }
        """ }
    Function ChangeZeroStringCommandToFunction String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get SingleCommandSyntaxToFunction (&sLine) CS_ZeroString to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Adjusts the casing of all scopes and keywords to match the casing as defined in the language configuration.
        This is a wrapper function for the cScintillaEdit editor.
        A visible (paged) instantiation of the cScintillaEdit class is needed for this function to operate properly.
        The DFRefactor program's 'Editor' view is used for this.
        { MethodType = eEditorFunction }
        { FnGroup = Cleanup }
        { SummaryText = Changed: Proper Upper and lowercasing }
        """ }
    Function EditorNormalizeCase String[] ByRef asCode String sParameter Returns Boolean
        Handle hoEditor
        Boolean bOK bChanged
        String[] asRefactoredCode
        tRefactorSettings RefactorSettings

        Get phoEditor to hoEditor
        If (hoEditor = 0) Begin
            Error "phoEditor = 0 (Function: EditorNormalizeCase)"
            Function_Return 0
        End

        Set Changed_State of hoEditor to False
        Send RefactorNormalizeCase of hoEditor
        Send PumpMsgQueue of Desktop
        Get Changed_State of hoEditor to bChanged

        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Reindents the source code with the number of spaces specified in the sParameter variable.
        This is a wrapper function for the cScintillaEdit editor.
        A visible (paged) instantiation of the cScintillaEdit class is needed for this function to operate properly.
        The DFRefactor program's 'Editor' view is used for this.
        { MethodType = eEditorFunction }
        { FnGroup = Cleanup }
        { SummaryText = Reindented code }
        { EnumList = 1,2,3,4,5,6,7,8}
        { InitialValue = 4}
        { ParamHelp = Select the indent size you want to use for spaces when indenting code
        \nand when breaking a line on rewriting a single line to multiple lines.
        \nIt is the same value that can be set on the Editor Settings dialog tab size.
        """ }
    Function EditorReIndent String[] ByRef asCode String sParameter Returns Boolean
        Handle hoEditor
        Boolean bOK bChanged
        String[] asRefactoredCode
        tRefactorSettings RefactorSettings

        Get phoEditor to hoEditor
        If (hoEditor = 0) Begin
            Error "phoEditor = 0 (Function: EditorReIndent)"
            Function_Return 0
        End
        // This is automatically set by the _InitTabSize message in cBaseFuncLib
        // when the program is started.
        If (num_arguments > 1) Begin
            Set piTabSize of hoEditor to sParameter
        End

        Set Changed_State of hoEditor to False
        Send RefactorReIndent of hoEditor
        Send GotoLine of hoEditor 0
        Send PumpMsgQueue of Desktop
        Get Changed_State of hoEditor to bChanged

        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
         A array variable declaration like e.g. "String [] asAddress", is changed to: "String[] asAddress"
         (Note the removed SPACE between "String" and "[]".
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Changed: NormalizeArrayNotation }
        """ }
    Function NormalizeArrayNotation String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get _NormalizeArrayNotation (&sLine) to bChanged
        Function_Return bChanged
    End_Function
    
    { Published = True }
    { Description = """
        Removes end of line comments for: End_Class, End_Object, End_Function & End_Procedure.
        { MethodType = eStandardFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: End comments }
        """ }
    Function RemoveEndComments String ByRef sLine String sParameter Returns Boolean
        Boolean bFound bChanged
        String sOrig
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bIsBlank = True or TokenizerData.bIsComment = True or TokenizerData.sEndComment = "") Begin
            Function_Return False
        End
        Get IsValidRemoveEndCommentsLine sLine to bFound
        If (bFound = False) Begin
            Function_Return False
        End

        Move sLine to sOrig
        Get _RemoveEndComment sLine to sLine
        Move (sLine <> sOrig) to bChanged
        If (bChanged = True) Begin
            // _RemoveEndComment no longer Rtrims; do it here so the user-visible
            // refactor output stays as it was (e.g. "End_Class // foo" becomes
            // "End_Class", not "End_Class " with trailing whitespace).
            Move (Rtrim(sLine)) to sLine
        End
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Removes 'Local' keyword if present from procedures and functions variable declaration lines.
        { MethodType = eStandardFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: 'Local' key word }
        """ }
    Function RemoveLocalKeyWord String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        String sText
        Integer iPos
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bIsVariableDeclaration = False) Begin
            Function_Return False
        End

        Move False to bChanged
        Move (LTrim(sLine)) to sText
        Move (Left(sText, 6)) to sText
        Move (Lowercase(sText)) to sText
        If (sText = (Lowercase(CS_Local) + CS_S)) Begin
            // local must be the first word on the line.
            // Now find the local statement and remove it.
            Move (Lowercase(sLine)) to sText
            Move (Pos((Lowercase(CS_Local) + CS_S), sText)) to iPos
            If (iPos > 0) Begin
                Move (Remove(sLine, iPos, 6)) to sLine
                Move True to bChanged
            End
        End
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Removes blank lines if more than xx 'Max blank lines'
        Removes consecutive empty blank lines if more than sParameter value.
        Takes a source file as a string array as a parameter.
        Returns the passed string array with removed duplicated empty lines.
        { MethodType = eOtherFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: Consecutive blank Lines }
        { EnumList = 1,2,3,4,5,6}
        { InitialValue = 2 }
        { ParamHelp = Select max number of consecutive blank lines allowed in source files. }
        """ }
    Function RemoveMultipleBlankLines String[] ByRef asCode String sParameter Returns Integer
        String[] asCodeOut
        Integer iCount iSize iCurrentNoOfEmptyLines iEmptyLines iMaxNoOfEmptyLines
        String sLine
        Boolean bImageStart bImageEnd bMakeImageTest

        Move False to bImageStart
        Move False to bImageEnd
        Move True  to bMakeImageTest
        Move 0 to iCurrentNoOfEmptyLines
        Move sParameter to iMaxNoOfEmptyLines

        Move (SizeOfArray(asCode)) to iSize
        Decrement iSize

        For iCount from 0 to iSize
            Move (Trim(asCode[iCount])) to sLine

            If (bMakeImageTest = True) Begin
                If (bImageStart = False and bImageEnd = False) Begin
                    Get IsImageStart sLine to bImageStart
                End
            End

            If (bImageStart = False and bImageEnd = False) Begin
                If (sLine = "") Begin
                    Increment iCurrentNoOfEmptyLines
                End
                Else Begin
                    Move 0 to iCurrentNoOfEmptyLines
                End
            End
            If (iCurrentNoOfEmptyLines <= iMaxNoOfEmptyLines) Begin
                Move asCode[iCount] to asCodeOut[SizeOfArray(asCodeOut)]
            End

            If (bMakeImageTest = True) Begin
                If (bImageStart = True) Begin
                    Get IsImageEnd sLine to bImageEnd
                    If (bImageEnd = True) Begin
                        Move False to bImageStart
                        Move False to bImageEnd
                        Move False to bMakeImageTest
                    End
                End
            End
        Loop

        Move (SizeOfArray(asCode) - SizeOfArray(asCodeOut)) to iEmptyLines
        Move asCodeOut to asCode

        Function_Return iEmptyLines
    End_Function

    { Published = True }
    { Description = """
        Removes legacy IDE markers '//AB-Store' etc.
        Returns True if at least one legacy IDE (Studio) source code marker was found.
        { MethodType = eRemoveFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: Legacy IDE markers }
        """ }
    // ToDo: Make this into a MethodType = eRemoveFunctionAll, and pass a string array containing one source file?
    Function RemoveOldStudioMarkers String ByRef sLine Returns Boolean
        Boolean bFound
        String sTrimmedLine
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        Move False to bFound
        Move (Trim(sLine)) to sTrimmedLine

        Case Begin
            Case (sTrimmedLine = "//AB-IgnoreStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-IgnoreEnd")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-StoreStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-StoreEnd")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-StoreTopStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-StoreTopEnd")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-PanelStoreTopStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-PanelStoreTopEnd")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-PanelStoreStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-PanelStoreEnd")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-ClientStoreTopStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-ClientStoreTopEnd")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-ClientStoreStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-ClientStoreEnd")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-DDOStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-DDOEnd")
                Move True to bFound
                Case Break
            Case (Left(sTrimmedLine, 6) = "//AB/ ")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-MenuPackage")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-End")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-ToolbarPackage")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-ViewStart")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-ViewEnd")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//AB-StatusBarPackage")
                Move True to bFound
                Case Break
            Case (sTrimmedLine = "//IDE-FileType=ftApplication")
                Move True to bFound
                Case Break
        Case End

        Function_Return bFound
    End_Function

    { Published = True }
    { Description = """
        Removes legacy Register_Object structures on top of e.g. view files.
        It removes old style Studio 'Project Object Structures"
        It does not do so for WebApp (*.wo) files.
        { MethodType = eRemoveFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: Register_Object structures }
        """ }
    Function RemoveProjectObjectStructure String ByRef sLine String sParameter Returns Boolean
        Boolean bWriteLine bRegisterAllObjectsStart bRegisterAllObjectsEnd
        Boolean bProjectObjectStructureStart bProjectObjectStructureEnd
        String[] asObjectNames
        tTokenizer TokenizerData

        Move True to bWriteLine
        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsVariableDeclaration = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInClass = True or TokenizerData.bIsInImage = True or TokenizerData.bIsInFunction = True or ;
            TokenizerData.bIsInProcedure = True or TokenizerData.bIsInDF23MultiLineString = True) Begin
            Function_Return False
        End

        Get pbRegisterAllObjectsStart     to bRegisterAllObjectsStart
        Get pbRegisterAllObjectsEnd       to bRegisterAllObjectsEnd
        Get pbProjectObjectStructureStart to bProjectObjectStructureStart
        Get pbProjectObjectStructureEnd   to bProjectObjectStructureEnd
        Get pasObjectNames                to asObjectNames

        If (bRegisterAllObjectsEnd = False) Begin
            If (bRegisterAllObjectsStart = False) Begin
                Get IsRegisterAllObjectsStart sLine to bRegisterAllObjectsStart
                Set pbRegisterAllObjectsStart        to bRegisterAllObjectsStart
            End
            If (bRegisterAllObjectsStart = True) Begin
                Get IsRegisterObjectInArray sLine asObjectNames to bWriteLine
                Move False to bProjectObjectStructureStart
                Set           pbProjectObjectStructureStart to False
            End
            If (bRegisterAllObjectsStart = False and bProjectObjectStructureEnd = False and bProjectObjectStructureStart = False) Begin
                Get IsProjectObjectStructureStart sLine to bProjectObjectStructureStart
                Set pbProjectObjectStructureStart       to bProjectObjectStructureStart
            End
            If (bProjectObjectStructureStart = True) Begin
                Get IsProjectObjectStructureLine sLine (&asObjectNames) to bWriteLine
            End
            Get IsRegisterAllObjectsEnd sLine to bRegisterAllObjectsEnd
            If (bRegisterAllObjectsEnd = True) Begin
                Send ClearProjectObjectStructureProperties
                // This means that we won't bother with the rest of the file.
                Set pbRegisterAllObjectsEnd to True
            End
        End
        If (bWriteLine = False) Begin
            Move "" to sLine
        End
        Function_Return (bWriteLine = False)
    End_Function

    { Published = True }
    { Description = """
        Removes 'Private' keyword from Property declaration lines.
        { MethodType = eStandardFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: 'Private' property key word }
        { ModRecipe = 4535 | Private or Public keyword }
        """ }
    Function RemovePropertyPrivate String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get RemovePropertyPublicPrivate (&sLine) "private" to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Removes 'Public' property members from property declaration lines.
        { MethodType = eStandardFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: 'Public' property key word }
        { ModRecipe = 4535 | Private or Public keyword }
        """ }
    Function RemovePropertyPublic String ByRef sLine String sParameter Returns Boolean
        Boolean bChanged
        Get RemovePropertyPublicPrivate (&sLine) "public" to bChanged
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Removes "MS Sans Serif" font source lines.
        { MethodType = eRemoveFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: 'MS Sans Serif' lines }
        """ }
    Function RemoveSansSerif String byref sLine Returns Boolean
        String sTest
        Boolean bWriteLine

        Move False to bWriteLine
        Move (Lowercase(Trim(sLine))) to sTest
        Move (Replaces(CS_S, sTest, ""))  to sTest
        Move (Replaces("'", sTest, "*")) to sTest
        Move (Replaces('"', sTest, "*")) to sTest
        If (sTest contains 'settypefaceto*mssansserif*') Begin
            Move True to bWriteLine
        End
        Function_Return bWriteLine
    End_Function

    { Published = True }
    { Description = """
        Removes old Studio generated comments lines.
        Examples:
        // fires when the button is clicked
        //OnChange is called on every changed character
        // Visual DataFlex xx.x Client Size Adjuster
        // Visual DataFlex xx.x Migration Utility
        ...and so on
        { MethodType = eRemoveFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: Studio generated comments }
        """ }
    Function RemoveStudioGeneratedComments String ByRef sLine Returns Boolean
        String sText sComment sComment2
        Boolean bFound bChanged
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        Move False to bChanged
        Move (Trim(sLine)) to sText
        If (sText = "" or sText = CS_CommentSymbol or sText contains (CS_CommentSymbol + "AB") or TokenizerData.bIsComment = False) Begin
            Function_Return False
        End

        Move "fires when the button is clicked" to sComment
        Get IsStudioGeneratedComment sLine sComment to bFound
        If (bFound = True) Begin
            Move "" to sLine
            Function_Return True
        End

        Move "onchange is called on every changed character" to sComment
        Get IsStudioGeneratedComment sLine sComment to bFound
        If (bFound = True) Begin
            Move "" to sLine
            Function_Return True
        End

        Move "visual dataflex"      to sComment
        Move "client size adjuster" to sComment2
        Get IsStudioGeneratedComment sLine sComment sComment2 to bFound
        If (bFound = True) Begin
            Move "" to sLine
            Function_Return True
        End

        Move "visual dataflex"    to sComment
        Move "migration utility," to sComment2
        Get IsStudioGeneratedComment sLine sComment sComment2 to bFound
        If (bFound = True) Begin
            Move "" to sLine
            Function_Return True
        End

        Move "If you set Current_radio you must set this after the" to sComment
        Get IsStudioGeneratedComment sLine sComment to bFound
        If (bFound = True) Begin
            Move "" to sLine
            Function_Return True
        End

        Move "radio objects have been created AND after Notify_select_State has been" to sComment
        Get IsStudioGeneratedComment sLine sComment to bFound
        If (bFound = True) Begin
            Move "" to sLine
            Function_Return True
        End

        Move "created. i.e. Set in bottom-code at end!!" to sComment
        Get IsStudioGeneratedComment sLine sComment to bFound
        If (bFound = True) Begin
            Move "" to sLine
            Function_Return True
        End

        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Removes spaces at the end of lines (trailing spaces).
        { MethodType = eStandardFunction }
        { SummaryText = Removed: Spaces at end of line }
        { FnGroup = Cleanup }
        """ }
    Function RemoveTrailingSpaces String ByRef sLine Returns Boolean
        Integer iBefore iAfter
        Boolean bChanged
        tTokenizer TokenizerData

        Move (Length(sLine))     to iBefore
        Move (RTrim(sLine))      to sLine
        Move (Length(sLine))     to iAfter
        Move (iBefore <> iAfter) to bChanged

        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Removes variables from functions and procedures that aren't used.
        A limitation is that it does not remove unused *struct* variables.
        Pass a source file as a string array.
        Removes all unusad locally defined, in Procedures & Functions, for the
        passed string array. Returns number of removed unused local variables.
        { MethodType = eOtherFunction }
        { FnGroup = Cleanup }
        { SummaryText = Removed: Unused local variables }
        """ }
    Function RemoveUnusedLocals String[] ByRef asCode String sParameter Returns Integer
        Handle ho
        Integer iRetval

        Get Create (RefClass(cRemoveUnusedLocals)) to ho
        If (ho = 0) Begin
            Error "Could not create cRemoveUnusedLocals object."
            Function_Return 0
        End

        Set piNoOfUnusedLocalVariables of ho to 0
        Get RemoveUnusedLocals of ho (&asCode) to iRetval
        Send Destroy of ho

        Function_Return iRetval
    End_Function

    { Published = True }
    { Description = """
      The naming style of data-dictionaries *objects* over time has changed.
      The new style is:
        Object o<tablename>_DD is a c<TableName>Datadictionary
      They also have a switch so you can keep on using the legacy style name which is:
        Object o<tablename>_DD is a <tablename>_Datadictionary

      However before VDF12, this is how it looked:
        Object <tableName>_DD is a <tablename>_Datadictionary

      This caused tremendous headaches as due to the extra "o" we ended up with name clashes
      all over the place. Copying old code into new views/dialogs simply breaks and if your
      codebase has mixed styles then the compiler will not catch that.
      A code nightmare.

      Examples:
        <TableName>_DD - o<TableName>DD (eDDStudioStyle)
        <TableName>_DD - o<TableName>_dd (neDDNewStyle)
      { MethodType = eOtherFunctionAll }
      { FnGroup = Modernization }
      { SummaryText = Renamed DataDictionary objects }
      { EnumList = "eDDStudioStyle, eDDNewStyle, eDDOldStyle" }
      { InitialValue = eDDNewStyle }
      { ParamHelp = Valid values;
      \neDDStudioStyle - o<TableName>DD
      \neDDNewStyle - o<TableName>_dd
      \noDDOldStyle - <TableName>_DD }
      """ }
    Function RestyleDDOs String[] ByRef asFiles String sParameter Returns Integer
        String sHomePath
        Handle ho
        Boolean bIsStyle
        Integer iRetval iSize iCount eDDOStyle
        tRefactorSettings RefactorSettings
        tWorkspacePaths TargetWS OrgWS

        If (SizeOfArray(asFiles) <= 0) Begin
            Function_Return False
        End

        Get Create (RefClass(cDDOReStyler)) to ho
        If (ho = 0) Begin
            Error "Could not create cDDORestyler object (Function: RestyleDDOs)"
            Function_Return 0
        End

        // sParameter arrives as the enum NAME from the UI combo or as the numeric VALUE
        // from tests - resolve each member explicitly via _ParameterIsEnum (a bare Move
        // of the name into the Integer enum yields eDDUnknown; and NOTE the {EnumList}
        // display order differs from the Enum_List value order here, so positional
        // mapping would be wrong). Unmatched/blank keeps eDDUnknown, as before. NO
        // num_arguments guard - it is unreliable after nested sends/dynamic dispatch,
        // and an omitted parameter arrives as "" (no member matches).
        Get _ParameterIsEnum sParameter "eDDStudioStyle" eDDStudioStyle to bIsStyle
        If (bIsStyle = True) ;
            Move eDDStudioStyle to eDDOStyle
        Get _ParameterIsEnum sParameter "eDDNewStyle" eDDNewStyle to bIsStyle
        If (bIsStyle = True) ;
            Move eDDNewStyle to eDDOStyle
        Get _ParameterIsEnum sParameter "eDDOldStyle" eDDOldStyle to bIsStyle
        If (bIsStyle = True) ;
            Move eDDOldStyle to eDDOStyle

        // Path for the workspace we are refactoring: target if selected,
        // otherwise DFRefactor's own (defensive - RestyleDDOs is normally
        // invoked with a target workspace selected).
        Get pTargetWS of ghoApplication to TargetWS
        If (TargetWS.sHome <> "") Begin
            Move TargetWS.sHome to sHomePath
        End
        Else Begin
            Get pOrgWS of ghoApplication to OrgWS
            Move OrgWS.sHome to sHomePath
        End
        Set psHomeTarget  of ho to sHomePath
        Set peDDOStyle  of ho to eDDOStyle
        Set pasAllFiles of ho to asFiles
        Set pbStrict    of ho to False

        // StartDDORestyler briefly redirects the active filelist to the target
        // workspace for the one-time table enumeration only, then restores it
        // before the per-file processing - so DFRefactor's own error logging
        // stays intact even if the restyle raises errors.
        Get StartDDORestyler of ho to iRetval
        Send Destroy of ho

        Function_Return iRetval
    End_Function

    { Published = True }
    { Description = """
        Splits If/Else single lines to If/Else - Begin constructs.
        It does *not* split if the last word is = "Break", as that could
        change the program logic.
        The function accepts a parameter controlling the If/Else or Begin/End block constructs.
        Valid sParameters, See: EnumList;
        { MethodType = eStandardFunction }
        { FnGroup = Cleanup }
        { SummaryText = Split If/Else line }
        { EnumList = "eSplitBySpaceAndSemicolon, eSplitBySemicolon, eSplitToBeginEndBlock" }
        { InitialValue = eSplitToBeginEndBlock }
        { ParamHelp = Valid values;
        \neSplitBySpaceAndSemicolon - Split line with space and semicolon
        \neSplitBySemicolon - Split line with semicolon
        \neSplitToBeginEndBlock - Use a Begin/End block }
        """ }

    Function SplitInlineIfElseLine String ByRef sLine String sParameter Returns Boolean
        Boolean bStop bChanged bFound
        Integer iIndent eSplitBy iTabSize iItem
        String  sText sToken
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End
        Move (SearchArray(CS_If, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem = -1) Begin
            Move (Trim(sLine)) to sText
            Move (Left(sText, 3)) to sText
            Move (Lowercase(sText) = Lowercase(CS_If)) to bFound
            If (bFound = False) Begin
                Function_Return False
            End
        End
        
        // Note: We do *not* change the line if it ends with a "Break", or if it contains
        //       a "Goto" or "Gosub", because wrapping those in a Begin/End block would
        //       change the logic of the program.
        Move TokenizerData.iTokenCount to iItem
        If (iItem = 0) ;
            Function_Return False
        Move TokenizerData.asLineTokens[iItem -1] to sToken
        If (Lowercase(sToken) = "break") Begin
            Function_Return False
        End
        Move (SearchArray("goto",  TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) ;
            Function_Return False
        Move (SearchArray("gosub", TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
        If (iItem <> -1) ;
            Function_Return False
        
        Move False to bChanged
        // sParameter arrives as the enum NAME from the UI combo or as the numeric VALUE
        // from tests - resolve via _ParameterIsEnum (a bare Move of the name into the
        // Integer enum yielded eSplitUnknown from the UI). Default = the documented
        // {InitialValue}, eSplitToBeginEndBlock.
        Move eSplitToBeginEndBlock to eSplitBy
        Get _ParameterIsEnum sParameter "eSplitBySpaceAndSemicolon" eSplitBySpaceAndSemicolon to bFound
        If (bFound = True) ;
            Move eSplitBySpaceAndSemicolon to eSplitBy
        Get _ParameterIsEnum sParameter "eSplitBySemicolon" eSplitBySemicolon to bFound
        If (bFound = True) ;
            Move eSplitBySemicolon to eSplitBy
        Get piTabSize to iTabSize
        If (eSplitBy = eSplitToBeginEndBlock) Begin
            Move (SearchArray(CS_Begin, TokenizerData.asLineTokens, Desktop, RefFunc(DFSTRICMP))) to iItem
            If (iItem <> -1) ;
                Function_Return False
        End

        Move (LTrim(sLine))     to sText
        Move (Pos(sText,sLine) - 1) to iIndent
        Move (Left(sText, 3))   to sText
        Move (Lowercase(sText)) to sText
        If (sText = (Lowercase(CS_If) + CS_S)) Begin
            Get IsLineEndSemiColonOrBegin TokenizerData.sOverstrikeLine to bStop
            If (bStop = False) Begin
                // It's one of those single line if statements, break it up
                Move (Lowercase(sLine)) to sText
                Get BreakupCompoundStatement iIndent (&sLine) eSplitBy iTabSize to bChanged
            End
        End
        Else Begin
            Move (LTrim(sLine))     to sText
            Move (Left(sText, 5))   to sText
            Move (Lowercase(sText)) to sText
            If (sText = (Lowercase(CS_Else) + CS_S)) Begin
                Get IsLineEndSemiColonOrBegin TokenizerData.sOverstrikeLine to bStop
                If (bStop = False) Begin
                    Get BreakupCompoundStatement iIndent (&sLine) eSplitBy iTabSize to bChanged
                End
            End
        End
        Function_Return bChanged
    End_Function

    { Published = True }
    { Description = """
        Refactors legacy DbGrid objects to a CJ grid class with individual column objects.
        For each matching DbGrid object found across all selected files:
          - The scope is code within the legacy object, not the entire file.
          - Renames the class to the new grid class.
          - Converts the Begin_Row / Entry_Item list into individual column child objects.
          - Maps Set Form_Width Item N to W  ->  Set piWidth to W  on each column.
          - Maps Set Header_Label Item N to "L"  ->  Set psCaption to "L"  on each column.
          - Removes legacy-only grid properties: Main_File, Wrap_State, peResizeColumn, psColumnsID.
          - Removes the standard Entry_Display boilerplate procedure.
          - Preserves all other content (other Set properties, nested objects, etc.) unchanged.
        sParameter must be a comma-separated list of 2 or 3 class names:
          OldGridClass,NewGridClass[,NewColumnClass]
        Example: "cLangdbGrid,cDbCJGrid,cDbCJGridColumn"
        If sParameter is empty, any class ending in "dbgrid" is detected, and the
        standard DataFlex classes cDbCJGrid and cDbCJGridColumn are used as targets.
        Returns the total number of grid objects transformed across all files.
        { MethodType = eOtherFunctionAll }
        { FnGroup = Modernization }
        { EnumList = "ANY" }
        { InitialValue = DbGrid,cDbCJGrid,cDbCJGridColumn }
        { SummaryText = Refactored: DbGrid -> cDbCJGrid }
        { ModRecipe = 4537 | class: DBGRID }
        { ParamHelp = Three comma separated class names;
        \nMyDbGrid - Your subclass of DbGrid,
        \nMycDbCJGrid - Your subclass of cDbCJGrid,
        \nMycDbCJGridColumn - Your subclass of cDbCJGridColumn }
        """ }
    Function RefactorDbGridTocDbCJGrid String[] ByRef asFiles String sParameter Returns Integer
        Handle  ho
        Integer iRetval

        If (SizeOfArray(asFiles) = 0) Begin
            Function_Return 0
        End

        Get Create (RefClass(cDbGridTocDbCJGrid)) to ho
        If (ho = 0) Begin
            Error "Could not create cDbGridTocDbCJGrid object. (Function: RefactorDbGridTocDbCJGrid)"
            Function_Return 0
        End

        Get TransformDbGridTocDbCJGrid of ho asFiles sParameter to iRetval
        Send Destroy of ho
        Function_Return iRetval
    End_Function

//  These comments were moved here from the { Description } meta tag, as it 
//  seems that the DataFlex metatag buffer was overflowed(?), leading to an unsuccessful compilation.
//
//  - Translates known properties to their cCJGrid equivalents, e.g.:
//      Set peResizeColumn          ->  Set pbAllowColumnResize
//      Set Prompt_Button_Mode      ->  Set pbHeaderPrompts
//      Set Allow_Top_Add_State     ->  Set pbAllowAppendRow
//      Set Allow_Bottom_Add_State  ->  Set pbAllowAppendRow
//      Set Allow_Insert_Add_State  ->  Set pbAllowInsertRow
//      Set Auto_Save_State         ->  Set pbAutoSave
//      Set No_Create_State         ->  Set pbAllowAppendRow + Set pbAllowInsertRow (inverted)
//      Set No_Delete_State         ->  Set pbAllowDeleteRow (inverted)
//      Set Read_Only_State         ->  Set pbReadOnly
//      Set CurrentRowColor         ->  Set piHighlightBackColor
//      Set CurrentCellColor        ->  Set piFocusCellBackColor
//      Set CurrentRowTextColor     ->  Set piHighlightForeColor
//      Set CurrentCellTextColor    ->  Set piFocusCellForeColor
    { Published = True }
    { Description = """
        Refactors legacy non-data-aware Grid objects to a CJ grid class.
        For each matching Grid object found across all selected files:
          - The scope is code within the legacy object, not the entire file.
          - Translates known properties to their cCJGrid equivalents
          - Renames the class to the new grid class.
          - Removes legacy-only grid properties: Wrap_State, peResizeColumn, psColumnsID.
          - Comments out the Entry_Display procedure body; any color Set properties
            found inside Entry_Display are translated and placed above the commented block.
          - Comments out legacy-only grid methods with a TODO marker.
          - Column sub-objects are NOT generated -- the non-data-aware column structure
            varies per use case and must be completed manually after refactoring.
        sParameter must be a comma-separated list of 2 or 3 class names:
          OldGridClass,NewGridClass[,NewGridColumnClass]
        Example: "cMyGrid,cCJGrid,cCJGridColumn"
        If sParameter is empty, any class whose name ends in "grid" (but not "dbgrid") is
        detected, and the standard DataFlex classes cCJGrid and cCJGridColumn are used as the target.
        Returns the total number of grid objects transformed across all files.
        { MethodType = eOtherFunctionAll }
        { FnGroup = Modernization }
        { EnumList = "ANY" }
        { InitialValue = Grid,cCJGrid, cCJGridColumn }
        { SummaryText = Refactored: Grid -> cCJGrid }
        { ModRecipe = 4537 | class: GRID }
        { ParamHelp = Three comma separated class names;
        \nMyGrid - Your subclass of Grid,
        \nMycCJGrid - Your subclass of cCJGrid,
        \nMycCJGridColumn - Your subclass of cCJGridColumn }
        """ }
    Function RefactorGridToCJGrid String[] ByRef asFiles String sParameter Returns Integer
        Handle  ho
        Integer iRetval

        If (SizeOfArray(asFiles) = 0) Begin
            Function_Return 0
        End

        Get Create (RefClass(cGridToCJGrid)) to ho
        If (ho = 0) Begin
            Error "Could not create cGridToCJGrid object. (Function: RefactorGridToCJGrid)"
            Function_Return 0
        End

        Get TransformGridToCJGrid of ho asFiles sParameter to iRetval
        Send Destroy of ho
        Function_Return iRetval
    End_Function

//  These comments were moved here from the { Description } meta tag, as it 
//  seems that the DataFlex metatag buffer was overflowed(?), leading to an unsuccessful compilation.
//
//          - Translates dbList selection properties to their cDbCJGridPromptList
//            equivalent (each with a TODO note where the mapping is approximate):
//              Auto_Server_State -> pbAutoServer, Auto_Column_State -> pbAutoColumn,
//              Popup_Search_State / Find_Search_State -> pbAutoSearch,
//              Export_Item_State -> peUpdateMode (umPromptValue/umPromptRelational).
//              Auto_Export_State / Auto_Index_State / Move_Value_Out_State /
//              Auto_Shadow_State / Auto_Label_State -> TODO comment only.
    { Published = True }
    { Description = """
        Refactors legacy dbList selection lists to cDbCJGridPromptList prompt lists.
        For each matching dbList object found across all selected files:
          - The scope is code within the legacy object, not the entire file.
          - Renames the class to the new prompt-list class.
          - Converts the Begin_Row / Entry_Item list into individual column child objects.
          - Maps Set Form_Width Item N to W  ->  Set piWidth to W  on each column.
          - Maps Set Header_Label Item N to "L"  ->  Set psCaption to "L"  on each column.
          - Emits a one-time TODO header reminding the developer that the invoking
            object needs a Prompt_Callback handler (peUpdateMode pattern).
          - The surrounding dbModalPanel and the invoking object are NOT modified;
            only the list object itself is transformed.
          - Preserves all other content (other Set properties, nested objects, etc.) unchanged.
        sParameter must be a comma-separated list of 2 or 3 class names:
          OldListClass,NewGridClass[,NewColumnClass]
        Example: "cMyDbList,cDbCJGridPromptList,cDbCJGridColumn"
        If sParameter is empty, any class ending in "dblist" is detected, and the
        standard DataFlex classes cDbCJGridPromptList and cDbCJGridColumn are used as targets.
        Returns the total number of list objects transformed across all files.
        { MethodType = eOtherFunctionAll }
        { FnGroup = Modernization }
        { EnumList = "ANY" }
        { InitialValue = dbList,cDbCJGridPromptList,cDbCJGridColumn }
        { SummaryText = Refactored: dbList -> cDbCJGridPromptList }
        { ModRecipe = 4537 | class: DBLIST }
        { ParamHelp = Three comma separated class names;
        \nMyDbList - Your subclass of DbList,
        \nMycDbCJGridPromptList - Your subclass of cDbCJGridPromptList,
        \nMycDbCJGridColumn - Your subclass of cDbCJGridColumn }
        """ }
    Function RefactorDbListTocDbCJGridPromptList String[] ByRef asFiles String sParameter Returns Integer
        Handle  ho
        Integer iRetval

        If (SizeOfArray(asFiles) = 0) Begin
            Function_Return 0
        End

        Get Create (RefClass(cDbListTocDbCJGridPromptList)) to ho
        If (ho = 0) Begin
            Error "Could not create cDbListTocDbCJGridPromptList object. (Function: RefactorDbListTocDbCJGridPromptList)"
            Function_Return 0
        End

        Get TransformDbListTocDbCJGridPromptList of ho asFiles sParameter to iRetval
        Send Destroy of ho
        Function_Return iRetval
    End_Function

    // ----- Unicode paradigm family -----
    // Refactors that bring pre-Unicode (DataFlex < 2022) source up to the
    // Unicode compiler's stricter rules. Logic lives in dedicated classes; see
    // cUnicodePointerToString.pkg.
    //
    // UnicodePointerToString fixes compile error 4539 ("Conversion from Pointer
    // to String is not allowed, use PointerToString function"). It wraps the
    // source of a bare  Move <pointer/address var> to <string var>  assignment
    // in PointerToString(), e.g. "Move aBuf to sResult" becomes
    // "Move (PointerToString(aBuf)) to sResult". Note an Address trips the same
    // 4539, so both Pointer and Address sources qualify. Only lines whose source
    // is a declared Pointer/Address local AND whose destination is a declared
    // String local (in the same method) are rewritten; anything whose operand
    // types can't be resolved is left untouched (a missed line is harmless, a
    // wrong wrap is not).

    { Published = True }
    { Description = """
        Unicode fix for compile error 4539: wraps the source of a bare
        "Move <pointer/address> to <string>" assignment in PointerToString().
        Conservative - rewrites only when both operand types are known from the
        local declarations. Pass one source file as a string array; returns the
        number of rewrites.
        { MethodType = eOtherFunction }
        { FnGroup = Modernization }
        { SummaryText = Wrapped: Pointer/Address -> String with PointerToString() }
        { ModRecipe = 4539 | pointer to string }
        """ }
    Function UnicodePointerToString String[] ByRef asCode String sParameter Returns Integer
        Handle  ho
        Integer iRetval

        Get Create (RefClass(cUnicodePointerToString)) to ho
        If (ho = 0) Begin
            Error "Could not create cUnicodePointerToString object. (Function: UnicodePointerToString)"
            Function_Return 0
        End

        Get UnicodePointerToString of ho (&asCode) to iRetval
        Send Destroy of ho
        Function_Return iRetval
    End_Function

    // UnicodeStringToPointer fixes the OTHER direction of 4539 ("Conversion from
    // String to Pointer is not allowed, use MemCopy function"). It rewrites a bare
    //   Move <string var> to <pointer/address var>
    // into the sanctioned MemCopy form
    //   Move (MemCopy(<ptr>, AddressOf(<str>), SizeOfString(<str>))) to iRFVoid
    // injecting the throwaway Integer (iRFVoid) once per method to receive
    // MemCopy's return. Unlike UnicodePointerToString it also reads the method's
    // String / Pointer parameters, because the string source of these conversions
    // is usually a parameter. Only rewrites when both operand types are known from
    // declarations/parameters; a missed line is harmless, a wrong rewrite is not.
    // The byte count is SizeOfString (encoding-aware); the buffer's ResizeArray
    // line is left untouched.

    { Published = True }
    { Description = """
        Unicode fix for compile error 4539 (String -> Pointer direction): rewrites a
        bare "Move <string> to <pointer>" into a MemCopy() call. Conservative -
        rewrites only when both operand types are known from declarations/parameters.
        Pass one source file as a string array; returns the number of rewrites.
        { MethodType = eOtherFunction }
        { FnGroup = Modernization }
        { SummaryText = Rewrite: String -> Pointer with MemCopy() }
        { ModRecipe = 4539 | string to pointer }
        """ }
    Function UnicodeStringToPointer String[] ByRef asCode String sParameter Returns Integer
        Handle  ho
        Integer iRetval

        Get Create (RefClass(cUnicodeStringToPointer)) to ho
        If (ho = 0) Begin
            Error "Could not create cUnicodeStringToPointer object. (Function: UnicodeStringToPointer)"
            Function_Return 0
        End

        Get UnicodeStringToPointer of ho (&asCode) to iRetval
        Send Destroy of ho
        Function_Return iRetval
    End_Function

    // UnicodeOemAnsiFunctions modernizes the legacy OEM/ANSI string-conversion calls
    // (the "String" section of the Unicode guide): under the Unicode compiler ToOEM()
    // and ToANSI() became Utf8ToOem() and Utf8ToAnsi(). Line-by-line
    // (eStandardFunction) because the rename is purely local - no cross-line state -
    // unlike the two functions above. The per-line overstrike the engine leaves in
    // pTokenizer lets it skip strings/comments, and a left word-boundary keeps it
    // idempotent (won't touch an already-converted Utf8ToOem). The boundary-aware,
    // masked token-rename primitive lives in cRefactorUtilities._RenameMaskedCalls.
    { Published = True }
    { Description = """
        Unicode fix for the legacy OEM/ANSI string-conversion calls: rewrites
        ToOEM(x) to Utf8ToOem(x) and ToANSI(x) to Utf8ToAnsi(x). Whole-word and
        idempotent (an already-converted Utf8ToOem is left alone); skips strings and
        comments.
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Renamed: ToOEM/ToANSI -> Utf8ToOem/Utf8ToAnsi }
        { ModRecipe = 4534 | use of ToOEM }
        { ModRecipe = 4534 | use of ToANSI }
        """ }
    Function UnicodeOemAnsiFunctions String ByRef sLine String sParameter Returns Boolean
        String   sNewLine sOverFull
        String[] asFrom asTo
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Move "ToOEM"      to asFrom[0]
        Move "Utf8ToOem"  to asTo[0]
        Move "ToANSI"     to asFrom[1]
        Move "Utf8ToAnsi" to asTo[1]

        // sOverstrikeLine is the LEFT-trimmed, masked line (the leading whitespace is
        // held separately in sIndentation). Re-attach it so the masked line is
        // position-aligned with the full sLine before the rename.
        Move (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) to sOverFull
        Get _RenameMaskedCalls sLine sOverFull asFrom asTo to sNewLine
        If (sNewLine = sLine) Begin
            Function_Return False
        End
        Move sNewLine to sLine
        Function_Return True
    End_Function

    // UnicodeRetireRedundantConversions - comments out a file's OWN global OEM/ANSI/UTF-8 conversion
    // functions once DataFlex (CharTranslate.pkg, DF26) provides them as built-ins, so duplicate-global
    // error 4390 goes away. The whole Function...End_Function / End_Procedure block is commented out -
    // REVERSIBLE, never deleted - prefixed with a marker explaining the retire and cautioning to verify the
    // built-in matches the old implementation (it COULD differ - a different code page, error handling, ...).
    // Only GLOBAL (top-level, Class/Object depth 0) definitions are touched; a same-named method inside a
    // class is left alone (a method does not clash with the global built-in). The 10 names are exactly DF26
    // CharTranslate's global functions; a file that hand-rolled that family clashes on all of them, so
    // retiring any one (via the 4390 recipe) cleans the lot. Idempotent: an already-commented block no longer
    // starts with Function/Procedure, so it is skipped.
    { Published = True }
    { Description = """
        Retires (comments out) a file's own global OEM/ANSI/UTF-8 conversion functions that now duplicate the
        DataFlex built-ins and trip error 4390. Reversible - the block is commented, not deleted, with a marker.
        Only global (top-level) definitions are touched; a same-named method inside a class is left alone.
        { MethodType = eOtherFunction }
        { FnGroup = Modernization }
        { SummaryText = Retired: redundant OEM/ANSI/UTF-8 conversion globals (now DataFlex built-ins) }
        { ModRecipe = 4390 | OemToUtf8 | Suggest }
        { ModRecipe = 4390 | Utf8ToOem | Suggest }
        { ModRecipe = 4390 | AnsiToUtf8 | Suggest }
        { ModRecipe = 4390 | Utf8ToAnsi | Suggest }
        """ }
    Function UnicodeRetireRedundantConversions String[] ByRef asCode String sParameter Returns Integer
        String[] asOut asNames
        String sLine sTrim sTok sFirst sRest sName sNameLow sIndent sBlk sBT sBIndent sEndTrim sEndTok
        Integer iSize iRetired iDepth iCount iSkipUntil iSpace iEnd iJ iName iP iSp2
        Boolean bFound

        // The DF26 CharTranslate.pkg global conversion functions (lowercased, for name matching).
        Move "oemtoutf8"         to asNames[0]
        Move "utf8tooem"         to asNames[1]
        Move "ansitoutf8"        to asNames[2]
        Move "utf8toansi"        to asNames[3]
        Move "oemtoutf8buffer"   to asNames[4]
        Move "utf8tooembuffer"   to asNames[5]
        Move "oemtoutf16buffer"  to asNames[6]
        Move "utf16tooembuffer"  to asNames[7]
        Move "multitowidebuffer" to asNames[8]
        Move "widetomultibuffer" to asNames[9]

        Move 0  to iRetired
        Move 0  to iDepth
        Move -1 to iSkipUntil
        Move (SizeOfArray(asCode)) to iSize
        Decrement iSize
        For iCount from 0 to iSize
            // Lines inside a just-retired block were already emitted (commented) - skip them.
            If (iCount > iSkipUntil) Begin
                Move asCode[iCount] to sLine
                Move (Trim(sLine)) to sTrim
                // Tab-normalize for first/second-token extraction (codebase convention).
                Move (Trim(Replaces((Character(9)), sTrim, " "))) to sTok
                Move (Pos(" ", sTok)) to iSpace
                If (iSpace > 0) Begin
                    Move (Lowercase(Trim(Left(sTok, (iSpace - 1))))) to sFirst
                End
                Else Begin
                    Move (Lowercase(sTok)) to sFirst
                End

                If ((sFirst = "class") or (sFirst = "object")) Begin
                    Increment iDepth
                    Move sLine to asOut[SizeOfArray(asOut)]
                End
                Else If ((sFirst = "end_class") or (sFirst = "end_object")) Begin
                    If (iDepth > 0) ;
                        Move (iDepth - 1) to iDepth
                    Move sLine to asOut[SizeOfArray(asOut)]
                End
                Else If ((iDepth = 0) and ((sFirst = "function") or (sFirst = "procedure"))) Begin
                    // Second token = the function name.
                    Move (Trim(Right(sTok, (Length(sTok) - iSpace)))) to sRest
                    Move (Pos(" ", sRest)) to iName
                    If (iName > 0) Begin
                        Move (Left(sRest, (iName - 1))) to sName
                    End
                    Else Begin
                        Move sRest to sName
                    End
                    Move (Lowercase(sName)) to sNameLow
                    If (SearchArray(sNameLow, asNames) <> -1) Begin
                        // Find the closing End_Function / End_Procedure (the first one - functions don't nest).
                        Move -1 to iEnd
                        Move False to bFound
                        Move (iCount + 1) to iJ
                        While ((iJ <= iSize) and (bFound = False))
                            Move (Trim(Replaces((Character(9)), asCode[iJ], " "))) to sEndTrim
                            Move (Pos(" ", sEndTrim)) to iSp2
                            If (iSp2 > 0) Begin
                                Move (Lowercase(Left(sEndTrim, (iSp2 - 1)))) to sEndTok
                            End
                            Else Begin
                                Move (Lowercase(sEndTrim)) to sEndTok
                            End
                            If ((sEndTok = "end_function") or (sEndTok = "end_procedure")) Begin
                                Move iJ to iEnd
                                Move True to bFound
                            End
                            Increment iJ
                        Loop
                        If (bFound = True) Begin
                            // Marker (at the def line's indentation), then the commented-out block.
                            Move "" to sIndent
                            Move (Pos(sTrim, sLine)) to iP
                            If (iP > 1) ;
                                Move (Left(sLine, (iP - 1))) to sIndent
                            Move (sIndent + "// [DFRefactor] Retired: global '" + sName + "' now duplicates the DataFlex built-in (was error 4390 - duplicate global).") to asOut[SizeOfArray(asOut)]
                            Move (sIndent + "// Verify the built-in matches this old implementation before relying on it; uncomment to restore.") to asOut[SizeOfArray(asOut)]
                            For iJ from iCount to iEnd
                                Move asCode[iJ] to sBlk
                                Move (Trim(sBlk)) to sBT
                                If (sBT = "") Begin
                                    Move "//" to sBlk
                                End
                                Else Begin
                                    Move "" to sBIndent
                                    Move (Pos(sBT, sBlk)) to iP
                                    If (iP > 1) ;
                                        Move (Left(sBlk, (iP - 1))) to sBIndent
                                    Move (sBIndent + "// " + sBT) to sBlk
                                End
                                Move sBlk to asOut[SizeOfArray(asOut)]
                            Loop
                            Increment iRetired
                            Move iEnd to iSkipUntil
                        End
                        Else Begin
                            // No closing End found - leave the line untouched.
                            Move sLine to asOut[SizeOfArray(asOut)]
                        End
                    End
                    Else Begin
                        Move sLine to asOut[SizeOfArray(asOut)]
                    End
                End
                Else Begin
                    Move sLine to asOut[SizeOfArray(asOut)]
                End
            End
        Loop

        If (iRetired > 0) ;
            Move asOut to asCode
        Function_Return iRetired
    End_Function

    // UnicodeWin64ReportExternalFunction audits External_Function / External_Procedure
    // declarations for the DF21+ (64-bit + Unicode) era and writes a report - it changes
    // NOTHING. The per-declaration analysis lives in cRefactorUtilities._AuditApiDeclaration
    // (+ _SuggestPointerType); this wrapper walks each selected file, joins ";"-continued
    // declaration lines into one logical line, runs the audit, and logs the findings to the
    // backup folder (surfaced via the 'Other Log Files' toolbar button, like the Unused* reports).
    { Published = True }
    { Description = """
        Reports Only! Makes no changes to the source code.
        Pass an array with *all selected source files*.
        Audits every External_Function / External_Procedure declaration: flags Integer/DWord
        parameters or returns whose name signals a pointer-sized Windows type (hWnd, lp*,
        lParam, *size*, ...) that should be Handle/Pointer/Longptr/ULongptr, and String
        parameters in an ANSI ("...A") entry-point wrapper that should be WString.
        Already-correct declarations are never flagged. See the 'Other Log Files' toolbar button.
        { MethodType = eReportFunctionAll }
        { FnGroup = Modernization }
        { SummaryText = Report: External_Function types to modernize for 64-bit/Unicode }
        """ }
    Function UnicodeWin64ReportExternalFunction String[] ByRef asFiles String sParameter Returns Integer
        String sHomePath sLogFile sFilePath sDecl sTrim sLC
        String[] asCode asFindings asEmpty asOtherLogFiles
        Integer iCh iFile iFileLast iLine iLineLast iDeclLine iN iFind iFindLast iTotal
        Boolean bFileHeader bPanel

        Get psHomeTarget of ghoApplication to sHomePath
        Move (vFolderFormat(sHomePath) + CS_BackupFolder + CS_DirSeparator + CS_UnicodeWin64ReportLogFile) to sLogFile
        Get rfOpenOutput sLogFile to iCh
        If (iCh < 0) Begin
            Function_Return 0
        End

        Writeln channel iCh "Win64 / Unicode External_Function audit  (report only - no changes made)."
        Writeln channel iCh "Flags Integer/DWord params or returns that should be Handle/Pointer/Longptr/ULongptr,"
        Writeln channel iCh "and String params in an ANSI (...A) entry-point wrapper that should be WString."
        Writeln channel iCh ""

        Move 0 to iTotal
        Move (SizeOfArray(asFiles)) to iFileLast
        Decrement iFileLast
        // This report loops files itself (eReportFunctionAll), so drive the status panel per
        // file - otherwise it looks frozen when this is the only function run.
        Move (ghoStatusPanel <> 0 and Active_State(ghoStatusPanel) = True) to bPanel
        If (bPanel = True) ;
            Set piMaximumTot of ghoStatusPanel to (iFileLast + 1)
        For iFile from 0 to iFileLast
            Move asFiles[iFile] to sFilePath
            If (bPanel = True) Begin
                Set Caption_Text of ghoStatusPanel to ("External_Function audit - File No:" * String(iFile + 1) * "of:" * String(iFileLast + 1))
                Set Title_Text of ghoStatusPanel to ("Auditing External_Function declarations:" * sFilePath)
                Send DoAdvanceTot of ghoStatusPanel
            End
            Move (RFReadEncodedFileAsStringArray(sFilePath)) to asCode
            Move False to bFileHeader
            Move (SizeOfArray(asCode)) to iLineLast
            If (iLineLast > 0) Begin
                Decrement iLineLast
                Move 0 to iLine
                While (iLine <= iLineLast)
                    Move (Replaces((Character(9)), asCode[iLine], " ")) to sTrim
                    Move (Trim(sTrim)) to sTrim
                    Move (Lowercase(sTrim)) to sLC
                    If (Left(sLC, 18) = "external_function " or Left(sLC, 19) = "external_procedure ") Begin
                        // Join ";"-continued lines into one logical declaration before auditing.
                        Move sTrim to sDecl
                        Move iLine to iDeclLine
                        While (Right(Trim(sDecl), 1) = ";" and iLine < iLineLast)
                            Move (Trim(Left(Trim(sDecl), (Length(Trim(sDecl)) - 1)))) to sDecl
                            Increment iLine
                            Move (sDecl + " " + Trim(asCode[iLine])) to sDecl
                        Loop
                        Move asEmpty to asFindings
                        Get _AuditApiDeclaration sDecl (&asFindings) to iN
                        If (iN > 0) Begin
                            If (bFileHeader = False) Begin
                                Writeln channel iCh ("=== " + sFilePath + " ===")
                                Move True to bFileHeader
                            End
                            Writeln channel iCh ("  Line " + String(iDeclLine + 1) + ":  " + Trim(sDecl))
                            Move (SizeOfArray(asFindings)) to iFindLast
                            Decrement iFindLast
                            For iFind from 0 to iFindLast
                                Writeln channel iCh ("        " + asFindings[iFind])
                            Loop
                            Add iN to iTotal
                        End
                    End
                    Increment iLine
                Loop
                If (bFileHeader = True) ;
                    Writeln channel iCh ""
            End
        Loop

        If (bPanel = True) ;
            Set Title_Text of ghoStatusPanel to ""
        Writeln channel iCh ("Total: " + String(iTotal) + " suggestion(s).")
        Send rfCloseOutput iCh

        If (iTotal > 0) Begin
            Get pasOtherLogFiles to asOtherLogFiles
            Move sLogFile to asOtherLogFiles[SizeOfArray(asOtherLogFiles)]
            Set pasOtherLogFiles to asOtherLogFiles
        End
        Function_Return iTotal
    End_Function

    // Report-only worksheet for the legacy buffer-offset Type system (4532). PART 1: each
    // "Type ... End_Type" with its proposed modern "Struct" (built by _TypeDefToStruct). PART 2:
    // every buffer accessor (Put / Put_String / StoreField / GETBUFF / RETRIEVEFIELD /
    // GetBuff_String / FillType / ZeroType / Offset_of_Field / Size_of_Field) with file + line.
    // These are byte-level ops needing human judgement (which String buffer is which instance), so
    // they are LISTED, never rewritten - review each (some "Put" lines may be unrelated). Logs to
    // the Backup folder; surfaced via the 'Other Log Files' toolbar button.
    { Published = True }
    { Description = """
        Reports Only! Makes no changes to the source code.
        Pass an array with *all selected source files*.
        Lists every legacy Type definition with a proposed modern Struct, plus the buffer accessors
        (Put / GETBUFF / StoreField / ...) to hand-migrate. See the 'Other Log Files' toolbar button.
        { MethodType = eReportFunctionAll }
        { FnGroup = Modernization }
        { SummaryText = Report: Type definitions -> proposed Structs + buffer-accessor usage sites }
        { ModRecipe = 4532 | Suggest }
        { ModRecipe = 4536 | Dftypes | Suggest }
        { ModRecipe = 4533 | ArrayPut | Suggest }
        { ModRecipe = 4534 | CVTtoBytes | Suggest }
        """ }
    Function TypeToStructReport String[] ByRef asFiles String sParameter Returns Integer
        String sHomePath sLogFile sFilePath sCmd sTok sPkg sMask sUsedName sCachePath sSuggest
        String[] asCode asEmpty asBlock asStruct asAccessors asOtherLogFiles asUsedTypes asFileUsed asWords
        Integer iCh iFile iFileLast iLine iLineLast iBlk iStart iTypes iUsages iTok iN iAcc
        Integer i j iUsed iDup iDefLast iTickA
        Boolean bPanel bFoundEnd bHeader bFound bCacheHit bHasCvt
        tTypeDef[] aCatalog aDefs
        tRFSearchResult[] aPkgFiles

        Get psHomeTarget of ghoApplication to sHomePath
        Move (vFolderFormat(sHomePath) + CS_BackupFolder + CS_DirSeparator + CS_TypeToStructReportLogFile) to sLogFile
        Get rfOpenOutput sLogFile to iCh
        If (iCh < 0) ;
            Function_Return 0

        Writeln channel iCh "Type -> Struct migration worksheet  (report only - no changes made)."
        Writeln channel iCh "Legacy Type/Field is a byte-offset buffer system, used mainly to marshal to"
        Writeln channel iCh "External_Functions. PART 1 proposes a modern Struct for each Type; PART 2 lists"
        Writeln channel iCh "the buffer accessors to hand-migrate to Struct + Move (which buffer maps to which"
        Writeln channel iCh "instance is a human decision, so nothing here is rewritten - review each line)."
        Writeln channel iCh ""

        Move "Put"             to asAccessors[0]
        Move "Put_String"      to asAccessors[1]
        Move "StoreField"      to asAccessors[2]
        Move "GETBUFF"         to asAccessors[3]
        Move "RETRIEVEFIELD"   to asAccessors[4]
        Move "GetBuff_String"  to asAccessors[5]
        Move "FillType"        to asAccessors[6]
        Move "ZeroType"        to asAccessors[7]
        Move "Offset_of_Field" to asAccessors[8]
        Move "Size_of_Field"   to asAccessors[9]
        Move "ArrayPut"        to asAccessors[10]   // Put into a Struct[] element (At <Type>.<field>)

        Move 0 to iTypes
        Move 0 to iUsages
        Move (SizeOfArray(asFiles)) to iFileLast
        Decrement iFileLast
        Move (ghoStatusPanel <> 0 and Active_State(ghoStatusPanel) = True) to bPanel
        // The TOTAL bar spans all three passes: Phase A (install-Pkg catalogue; its
        // count joins the budget once the search below has run), Phase B (selected
        // files) and PART 2 (selected files again). Previously only Phase B advanced
        // it, so the panel froze through the whole Phase A scan and PART 2. The
        // per-file bar is driven in PART 2's line loop (the only line-local pass).
        If (bPanel = True) Begin
            Set piMaximumTot of ghoStatusPanel to (2 * (iFileLast + 1))
            Set piPosition  of ghoProgressBar to 0
            Set piAdvanceBy of ghoProgressBar to 1
        End

        // ---- Phase A: catalogue Type defs from the TARGET install's packages (DfTypes.pkg & co.) ----
        // The Type definitions live in the system packages, not the user's code (which only USES them),
        // so resolve them from psTargetPkgFolder - the same Pkg folder the ModAnalyzer scans. Those
        // packages change on a DataFlex version bump (different version folder -> different cache name)
        // AND on an in-place update (same folder): the cache stamps the newest *.pkg write time and a
        // cache READ self-invalidates when a package is newer (ReadTypeDefsCache / _PkgScanIsStale), so
        // no manual JSON delete is needed. CACHED per version in Data\TypeDefs-<ver>.json; a SHARED
        // install-Pkg walk (ghoFuncLib.EnsureInstallCaches) builds it AND the ModAnalyzer recipe scan
        // in ONE pass; a fresh cache hit skips the walk entirely.
        Move (GetTickCount()) to iTickA
        Get TypeDefsCacheJsonPath of Self to sCachePath
        // Try the cache first (ONE parse on the common hit path - do NOT pre-probe, which would parse
        // this potentially-large JSON twice). A peer ModAnalyzer Analyze earlier this session may have
        // filled it via the shared walk's piggyback, so even a "first" report run can hit here.
        Get ReadTypeDefsCache of Self (&aCatalog) to bCacheHit
        If (bCacheHit = True) Begin
            If (bPanel = True) ;
                Set Title_Text of ghoStatusPanel to "Type catalogue loaded from cache..."
            Writeln channel iCh ("Type catalogue: " + String(SizeOfArray(aCatalog)) + " definitions loaded from cache (" + sCachePath + ") in " + String(GetTickCount() - iTickA) + " ms - install-package scan skipped.")
        End
        Else Begin
            // Stale - the ONE shared install-package walk reads every package ONCE and refreshes this
            // Type-def cache AND (if it too is stale) the ModAnalyzer recipe scan; it drives the
            // per-package total bar itself (bShowProgress = True). Then re-read the now-fresh cache.
            If (bPanel = True) ;
                Set Title_Text of ghoStatusPanel to "Cataloguing Type definitions from the packages..."
            Send EnsureInstallCaches of Self False True True
            Get ReadTypeDefsCache of Self (&aCatalog) to bCacheHit
            Writeln channel iCh ("Type catalogue: rebuilt from the install packages -> " + String(SizeOfArray(aCatalog)) + " definitions in " + String(GetTickCount() - iTickA) + " ms; cached to " + sCachePath + " for next run.")
        End
        Writeln channel iCh ""

        // ---- Phase B: add any user-defined Types to the catalogue, and collect the Types USED ----
        For iFile from 0 to iFileLast
            Move asFiles[iFile] to sFilePath
            If (bPanel = True) Begin
                // "File No: x of: y" counter (the engine sets this for line-by-line functions; an
                // eReportFunctionAll gets all files at once, so we set it ourselves - see cRefactorEngine).
                Set Caption_Text   of ghoStatusPanel to ("Type usage - File No:" * String(iFile + 1) * "of:" * String(iFileLast + 1))
                Set Title_Text of ghoStatusPanel to "Scanning Type usage:"
                Set TableName_Text of ghoStatusPanel to sFilePath
                Send DoAdvanceTot of ghoStatusPanel
            End
            Move (RFReadEncodedFileAsStringArray(sFilePath)) to asCode
            Get _TypeDefsFromLines of Self asCode to aDefs
            Move (SizeOfArray(aDefs) - 1) to iDefLast
            For j from 0 to iDefLast
                Move aDefs[j] to aCatalog[SizeOfArray(aCatalog)]
            Loop
            Get _UsedTypeNamesFromLines of Self asCode to asFileUsed
            Move (SizeOfArray(asFileUsed) - 1) to iDefLast
            For j from 0 to iDefLast
                Move (SearchArray(asFileUsed[j], asUsedTypes, Desktop, RefFunc(DFSTRICMP))) to iDup
                If (iDup = -1) ;
                    Move asFileUsed[j] to asUsedTypes[SizeOfArray(asUsedTypes)]
            Loop
        Loop

        // ---- PART 1: proposed Struct for each Type used in your code ----
        Writeln channel iCh "=== PART 1: proposed Struct for each Type used in your code ==="
        Writeln channel iCh ""
        Move (SizeOfArray(asUsedTypes) - 1) to iN
        For iUsed from 0 to iN
            Move asUsedTypes[iUsed] to sUsedName
            Move False to bFound
            Move asEmpty to asBlock
            Move (SizeOfArray(aCatalog) - 1) to iDefLast
            Move 0 to j
            While (j <= iDefLast and bFound = False)
                If (Lowercase(aCatalog[j].sName) = Lowercase(sUsedName)) Begin
                    Move True to bFound
                    Move aCatalog[j].asBlock to asBlock
                End
                Increment j
            Loop
            If (bFound = True) Begin
                Writeln channel iCh ("--- " + sUsedName + " ---")
                Get _TypeDefToStruct of Self asBlock to asStruct
                Move (SizeOfArray(asStruct) - 1) to iTok
                Move 0 to iBlk
                While (iBlk <= iTok)
                    Writeln channel iCh ("    " + asStruct[iBlk])
                    Increment iBlk
                Loop
                Writeln channel iCh ""
                Increment iTypes
            End
            Else Begin
                Writeln channel iCh ("--- " + sUsedName + "  (definition not found - check it is a Type) ---")
                Writeln channel iCh ""
            End
        Loop

        // ---- PART 2: buffer accessor usage sites ----
        Writeln channel iCh "=== PART 2: buffer accessor usage sites to hand-migrate ==="
        Writeln channel iCh "  A 'suggest:' line gives the mechanical Struct rewrite: the buffer becomes a Struct local"
        Writeln channel iCh "  named 'TheData' (rename its other uses to match) and the byte-offset Type. prefix drops."
        Writeln channel iCh "  REVIEW each: a buffer passed to an External_Function by AddressOf (e.g. a Windows API) must"
        Writeln channel iCh "  pass the Struct's address instead, and the field types must be 64-bit-correct (see the"
        Writeln channel iCh "  Win64StructPadding report). Nothing here is auto-applied."
        Writeln channel iCh ""
        For iFile from 0 to iFileLast
            Move asFiles[iFile] to sFilePath
            If (bPanel = True) Begin
                Set Caption_Text   of ghoStatusPanel to ("Buffer accessors - File No:" * String(iFile + 1) * "of:" * String(iFileLast + 1))
                Set Title_Text of ghoStatusPanel to "Scanning buffer accessors:"
                Set TableName_Text of ghoStatusPanel to sFilePath
                Send DoAdvanceTot of ghoStatusPanel
            End
            Move (RFReadEncodedFileAsStringArray(sFilePath)) to asCode
            Move (SizeOfArray(asCode)) to iLineLast
            Move False to bHeader
            If (bPanel = True) Begin
                Set piPosition of ghoProgressBar to 0
                Set piMaximum  of ghoProgressBar to iLineLast
            End
            If (iLineLast > 0) Begin
                Decrement iLineLast
                For iLine from 0 to iLineLast
                    // Per-file bar: the canonical ~20-line nudge (no-op without a panel).
                    If (Mod(iLine, 20) = 0 and bPanel = True) Begin
                        Send Update_StatusPanel of ghoStatusPanel ("Source line:" * String(iLine + 1) * "of:" * String(iLineLast + 1))
                        Set piPosition of ghoProgressBar to (iLine + 1)
                    End
                    // Stateless split (no engine Tokenizer): a report makes no source
                    // changes, so it never needed position accuracy; this is the cheap
                    // first-token check, with strings/// comments already masked out.
                    Get _SplitSourceWords of Self asCode[iLine] to asWords
                    Move -1 to iAcc
                    Move False to bHasCvt
                    If (SizeOfArray(asWords) > 0) Begin
                        Move (SearchArray(asWords[0], asAccessors, Desktop, RefFunc(DFSTRICMP))) to iAcc
                        // CVTtoBytes is a FUNCTION used mid-line ("Move (CVTtoBytes(...)) to x"), not a
                        // leading command, so the first-token check misses it - detect it by content on
                        // the masked split (strings / comments already stripped, so no false match).
                        Move (SizeOfArray(asWords) - 1) to iTok
                        For j from 0 to iTok
                            If (Uppercase(asWords[j]) contains "CVTTOBYTES") ;
                                Move True to bHasCvt
                        Loop
                    End
                    If (iAcc <> -1 or bHasCvt = True) Begin
                        If (bHeader = False) Begin
                            Writeln channel iCh ("--- " + sFilePath + " ---")
                            Move True to bHeader
                        End
                        Writeln channel iCh ("  Line " + String(iLine + 1) + ":  " + Trim(asCode[iLine]))
                        If (iAcc <> -1) Begin
                            Get _SuggestStructLine of Self asWords aCatalog to sSuggest
                            If (sSuggest <> "") ;
                                Writeln channel iCh ("      suggest:  " + sSuggest)
                        End
                        Else ;
                            Writeln channel iCh ("      suggest:  byte-packing - a Struct assignment ('Move <value> to TheData.<field>') lays out the bytes; no CVTtoBytes needed.")
                        Increment iUsages
                    End
                Loop
                If (bHeader = True) ;
                    Writeln channel iCh ""
            End
        Loop

        If (bPanel = True) ;
            Set Title_Text of ghoStatusPanel to ""
        Writeln channel iCh ("Total: " + String(iTypes) + " Type definition(s), " + String(iUsages) + " accessor line(s).")
        Send rfCloseOutput iCh

        If ((iTypes + iUsages) > 0) Begin
            Get pasOtherLogFiles to asOtherLogFiles
            Move sLogFile to asOtherLogFiles[SizeOfArray(asOtherLogFiles)]
            Set pasOtherLogFiles to asOtherLogFiles
        End
        Function_Return (iTypes + iUsages)
    End_Function

    { Published = True }
    { Description = """
      Reports Only! Makes no changes to the source code.
      Check all files in the current workspace to see if they are used, else list them in a report.
      Pass an array with *all source files*
      Returns a list of unused files. See the DFRefactor programs: 'Other Log Files' toolbar button for results.
      Alongside the report, a companion 'MoveUnusedSourceFiles.bat' is also written to the
      DFRefactor_Backup folder. Running it MOVES (never deletes) the listed files into a
      quarantine sub-folder, so the cleanup is reversible. Running it is entirely optional;
      the report's footnote points to the .bat and explains how to undo it.
      { MethodType = eReportFunctionAll }
      { FnGroup = Cleanup }
      { SummaryText = Creates a report of never-used files plus an optional .bat to quarantine them }
      """ }
    Function UnusedSourceFiles String[] ByRef asFiles String sParameter Returns Integer
        Handle ho
        Integer iRetval
        String sLogFile
        String[] asOtherLogFiles
        tRefactorSettings RefactorSettings

        Get Create (RefClass(cUnusedSourceFiles)) to ho
        If (ho = 0) Begin
            Error "Could not create cUnusedSourceFiles object."
            Function_Return 0
        End

        Get pRefactorSettings to RefactorSettings
        Get FindUnusedSourceFiles of ho RefactorSettings.FileData.asFullFileNames to iRetval

        If (iRetval <> 0) Begin
            Get pasOtherLogFiles to asOtherLogFiles
            Get psLogFile of ho  to asOtherLogFiles[SizeOfArray(asOtherLogFiles)]
            Set pasOtherLogFiles to asOtherLogFiles
        End
        Send Destroy of ho
        Function_Return iRetval
    End_Function

    { Published = True }
    { Description = """
      Reports Only! Makes no changes to the source code.
      Pass an array with *all selected source files*.
      For each file, scans all Use statements and finds all classes defined in each Use file.
      Reports any Use file whose classes are never instantiated by an Object in that file.
      Use files that contain only procedures or functions (no Class definitions) are excluded.
      Results are accumulated across all files into a single log file.
      See the DFRefactor programs: 'Other Log Files' toolbar button for results.
      { MethodType = eReportFunctionAll }
      { FnGroup = Cleanup }
      { SummaryText = Creates a report with unused Use statements }
      """ }
    Function UnusedUseStatements String[] ByRef asFiles String sParameter Returns Integer
        Handle ho
        Integer iRetval
        String sHomePath sLogFile
        String[] asOtherLogFiles

        Get Create (RefClass(cUnusedUseStatements)) to ho
        If (ho = 0) Begin
            Error "Could not create cUnusedUseStatements object."
            Function_Return 0
        End

        // DF_OPEN_PATH is already set to the target workspace's source folders
        // by cRefactorApplication.UpdateDFOpenPath when the workspace was opened.
        // No per-function path management is required here.
        Get psHomeTarget of ghoApplication to sHomePath
        Move (vFolderFormat(sHomePath)) to sHomePath
        Move (sHomePath + CS_BackupFolder + CS_DirSeparator + CS_UnusedUseStatementsLogFile) to sLogFile
        Set psLogFile of ho to sLogFile
        Get FindUnusedUseStatementsAllFiles of ho asFiles to iRetval

        If (pbOK(ho) = True) Begin
            Get pasOtherLogFiles to asOtherLogFiles
            Move sLogFile to asOtherLogFiles[SizeOfArray(asOtherLogFiles)]
            Set pasOtherLogFiles to asOtherLogFiles
        End
        Send Destroy of ho
        Function_Return iRetval
    End_Function

    // Win64AddressToPointer modernizes the legacy native-pointer TYPE for 64-bit: the guide
    // calls Pointer "a replacement for Address" (the same pointer-sized type), so a
    // declaration "Address pFoo" becomes "Pointer pFoo". Line-by-line (eStandardFunction);
    // renames ONLY the type slot of a declaration (first token, or the token after Property
    // / Global_Variable / Class_Global) via cRefactorUtilities._RenameLeadingType, which is
    // whole-word and never touches a field (Customer.Address), a longer identifier
    // (AddressOf, sAddress), or a variable merely named "Address". Parameter and "Returns"
    // types sit mid-signature and are intentionally out of scope here.
    { Published = True }
    { Description = """
        64-bit modernization: rewrites the declaration type Address to Pointer (the guide's
        named replacement for the native pointer type) - local variables, struct members,
        Property and Global_Variable declarations. Whole-word and idempotent; never touches
        AddressOf, fields, or a variable named "Address". Params/Returns types are out of scope.
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Renamed type: Address -> Pointer }
        """ }
    Function Win64AddressToPointer String ByRef sLine String sParameter Returns Boolean
        String sNewLine sOverFull
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bIsBlank = True or TokenizerData.bIsComment = True) Begin
            Function_Return False
        End

        Move (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) to sOverFull
        Get _RenameLeadingType sLine sOverFull "Address" "Pointer" to sNewLine
        If (sNewLine = sLine) Begin
            Function_Return False
        End
        Move sNewLine to sLine
        Function_Return True
    End_Function

    // Win64PointerTruncation is a REPORT-ONLY audit (makes no changes) for the 64-bit
    // pointer-truncation bug. The per-method analysis lives in the worker class
    // cWin64PointerTruncation; this wrapper walks each selected file, resets the lexer,
    // runs the audit, and writes a consolidated log (surfaced via the 'Other Log Files'
    // toolbar button, like the other report functions).
    { Published = True }
    { Description = """
        Reports Only! Makes no changes to the source code.
        Pass an array with *all selected source files*.
        64-bit truncation audit: flags a pointer-sized value moved into a 32-bit Integer/DWord
        (which silently truncates on x64) - either a declared Pointer/Address variable or
        parameter, or an AddressOf() result, assigned into an Integer/DWord. Per-method scope.
        See the 'Other Log Files' toolbar button for results.
        { MethodType = eReportFunctionAll }
        { FnGroup = Modernization }
        { SummaryText = Reported: pointer-to-Integer truncation risks (64-bit) }
        """ }
    Function Win64PointerTruncation String[] ByRef asFiles String sParameter Returns Integer
        Handle ho
        String sHomePath sLogFile sFilePath
        String[] asCode asFindings asEmpty asOtherLogFiles
        Integer iCh iFile iFileLast iN iFind iFindLast iTotal
        Boolean bPanel

        Get psHomeTarget of ghoApplication to sHomePath
        Move (vFolderFormat(sHomePath) + CS_BackupFolder + CS_DirSeparator + CS_Win64PointerTruncationLogFile) to sLogFile
        Get rfOpenOutput sLogFile to iCh
        If (iCh < 0) Begin
            Function_Return 0
        End

        Writeln channel iCh "Win64 pointer-truncation audit  (report only - no changes made)."
        Writeln channel iCh "Flags a Pointer/Address variable, or an AddressOf() result, moved into a"
        Writeln channel iCh "32-bit Integer/DWord - which silently truncates the pointer on x64."
        Writeln channel iCh ""

        Get Create (RefClass(cWin64PointerTruncation)) to ho
        If (ho = 0) Begin
            Send rfCloseOutput iCh
            Error "Could not create cWin64PointerTruncation object."
            Function_Return 0
        End

        Move 0 to iTotal
        Move (SizeOfArray(asFiles)) to iFileLast
        Decrement iFileLast
        // This report loops files itself (eReportFunctionAll), so drive the status panel per
        // file - otherwise it looks frozen when Win64PointerTruncation is the only function run.
        Move (ghoStatusPanel <> 0 and Active_State(ghoStatusPanel) = True) to bPanel
        If (bPanel = True) ;
            Set piMaximumTot of ghoStatusPanel to (iFileLast + 1)
        For iFile from 0 to iFileLast
            Move asFiles[iFile] to sFilePath
            If (bPanel = True) Begin
                Set Caption_Text of ghoStatusPanel to ("Pointer truncation - File No:" * String(iFile + 1) * "of:" * String(iFileLast + 1))
                Set Title_Text of ghoStatusPanel to ("Scanning for pointer truncation:" * sFilePath)
                Send DoAdvanceTot of ghoStatusPanel
            End
            Move (RFReadEncodedFileAsStringArray(sFilePath)) to asCode
            Move asEmpty to asFindings
            Send ClearFuncLibProperties of ghoFuncLib
            Get AuditFile of ho asCode (&asFindings) to iN
            If (iN > 0) Begin
                Writeln channel iCh ("=== " + sFilePath + " ===")
                Move (SizeOfArray(asFindings)) to iFindLast
                Decrement iFindLast
                For iFind from 0 to iFindLast
                    Writeln channel iCh asFindings[iFind]
                Loop
                Writeln channel iCh ""
                Add iN to iTotal
            End
        Loop

        If (bPanel = True) ;
            Set Title_Text of ghoStatusPanel to ""
        Send Destroy of ho
        Writeln channel iCh ("Total: " + String(iTotal) + " truncation risk(s).")
        Send rfCloseOutput iCh

        If (iTotal > 0) Begin
            Get pasOtherLogFiles to asOtherLogFiles
            Move sLogFile to asOtherLogFiles[SizeOfArray(asOtherLogFiles)]
            Set pasOtherLogFiles to asOtherLogFiles
        End
        Function_Return iTotal
    End_Function

    // Win64StructPadding is a REPORT-ONLY audit (makes no changes) for the 64-bit
    // struct-padding bug: DataFlex structs do not auto-pad like C, so a pointer-sized
    // member that does not land on an 8-byte boundary in a Win32-mirror struct needs an
    // explicit "#IFDEF Is$Win64 / Integer iAlign / #ENDIF" filler. The per-struct analysis
    // lives in the worker class cWin64StructPadding; this wrapper walks each selected file,
    // resets the lexer, runs the audit, and writes a consolidated log (surfaced via the
    // 'Other Log Files' toolbar button, like the other report functions).
    { Published = True }
    { Description = """
        Reports Only! Makes no changes to the source code.
        Pass an array with *all selected source files*.
        64-bit struct-padding audit: in each Struct...End_Struct, flags a pointer-sized member
        (Pointer/Address/Handle/Longptr/ULongptr) that does not land on an 8-byte-aligned offset
        and so needs an Is$Win64 filler. A struct with an indeterminate-size member, or that
        already uses an Is$Win64 conditional, is noted/skipped. See the 'Other Log Files' button.
        Report-only - apply the actual fix with DAW's "Structure Padding Helper" tool.
        { MethodType = eReportFunctionAll }
        { FnGroup = Modernization }
        { SummaryText = Reported: struct pointer-member alignment risks (64-bit) }
        """ }
    Function Win64StructPadding String[] ByRef asFiles String sParameter Returns Integer
        Handle ho
        String sHomePath sLogFile sFilePath
        String[] asCode asFindings asEmpty asOtherLogFiles
        Integer iCh iFile iFileLast iN iFind iFindLast iTotal
        Boolean bPanel

        Get psHomeTarget of ghoApplication to sHomePath
        Move (vFolderFormat(sHomePath) + CS_BackupFolder + CS_DirSeparator + CS_Win64StructPaddingLogFile) to sLogFile
        Get rfOpenOutput sLogFile to iCh
        If (iCh < 0) Begin
            Function_Return 0
        End

        Writeln channel iCh "Win64 struct-padding audit  (report only - no changes made)."
        Writeln channel iCh "Flags a pointer-sized struct member that is not 8-byte aligned on x64"
        Writeln channel iCh "and so needs an Is$Win64 filler. DataFlex structs do not auto-pad like C."
        Writeln channel iCh ""

        Get Create (RefClass(cWin64StructPadding)) to ho
        If (ho = 0) Begin
            Send rfCloseOutput iCh
            Error "Could not create cWin64StructPadding object."
            Function_Return 0
        End

        Move 0 to iTotal
        Move (SizeOfArray(asFiles)) to iFileLast
        Decrement iFileLast
        // This report loops files itself (eReportFunctionAll), so drive the status panel per
        // file - otherwise it looks frozen when Win64StructPadding is the only function run.
        Move (ghoStatusPanel <> 0 and Active_State(ghoStatusPanel) = True) to bPanel
        If (bPanel = True) ;
            Set piMaximumTot of ghoStatusPanel to (iFileLast + 1)
        For iFile from 0 to iFileLast
            Move asFiles[iFile] to sFilePath
            If (bPanel = True) Begin
                Set Caption_Text of ghoStatusPanel to ("Struct padding - File No:" * String(iFile + 1) * "of:" * String(iFileLast + 1))
                Set Title_Text of ghoStatusPanel to ("Scanning structs for 64-bit padding:" * sFilePath)
                Send DoAdvanceTot of ghoStatusPanel
            End
            Move (RFReadEncodedFileAsStringArray(sFilePath)) to asCode
            Move asEmpty to asFindings
            Send ClearFuncLibProperties of ghoFuncLib
            Get AuditFile of ho asCode (&asFindings) to iN
            If (iN > 0) Begin
                Writeln channel iCh ("=== " + sFilePath + " ===")
                Move (SizeOfArray(asFindings)) to iFindLast
                Decrement iFindLast
                For iFind from 0 to iFindLast
                    Writeln channel iCh asFindings[iFind]
                Loop
                Writeln channel iCh ""
                Add iN to iTotal
            End
        Loop

        If (bPanel = True) ;
            Set Title_Text of ghoStatusPanel to ""
        Send Destroy of ho
        Writeln channel iCh ("Total: " + String(iTotal) + " alignment finding(s).")
        Send rfCloseOutput iCh

        If (iTotal > 0) Begin
            Get pasOtherLogFiles to asOtherLogFiles
            Move sLogFile to asOtherLogFiles[SizeOfArray(asOtherLogFiles)]
            Set pasOtherLogFiles to asOtherLogFiles
        End
        Function_Return iTotal
    End_Function

    // Win64WindowLongFunctions modernizes the Get/Set Window/Class Long Win32 calls for
    // 64-bit (the "GetWindowLong/SetWindowLong/GetClassLong/SetClassLong truncate a
    // pointer" gotcha in the 64-bit guide): each is renamed to its *Ptr variant, which is
    // pointer-safe and works on both 32- and 64-bit. Line-by-line (eStandardFunction) -
    // the same masked, boundary-aware, idempotent rename as UnicodeOemAnsiFunctions
    // (cRefactorUtilities._RenameMaskedCalls): it skips strings/comments, and the *Ptr
    // suffix stops it from re-matching an already-converted call. NOTE: the renamed calls
    // need a matching *Ptr External_Function in scope - the DataFlex 21+ Windows packages
    // declare them; a hand-rolled GetWindowLong wrapper must add its own *Ptr declaration.
    { Published = True }
    { Description = """
        64-bit fix for the Win32 "long" calls that truncate pointers: rewrites
        GetWindowLong/SetWindowLong/GetClassLong/SetClassLong to their *Ptr variants
        (GetWindowLongPtr, etc.), which are pointer-safe on both 32- and 64-bit.
        Whole-word and idempotent; skips strings and comments.
        { MethodType = eStandardFunction }
        { FnGroup = Modernization }
        { SummaryText = Renamed: Get/SetWindowLong + Get/SetClassLong -> *Ptr }
        """ }
    Function Win64WindowLongFunctions String ByRef sLine String sParameter Returns Boolean
        String   sNewLine sOverFull
        String[] asFrom asTo
        tTokenizer TokenizerData

        Get pTokenizer to TokenizerData
        If (TokenizerData.bLineIsReady = True or TokenizerData.bIsInCommand = True or ;
            TokenizerData.bIsInImage = True or TokenizerData.bIsVariableDeclaration = True) Begin
            Function_Return False
        End

        Move "GetWindowLong"    to asFrom[0]
        Move "GetWindowLongPtr" to asTo[0]
        Move "SetWindowLong"    to asFrom[1]
        Move "SetWindowLongPtr" to asTo[1]
        Move "GetClassLong"     to asFrom[2]
        Move "GetClassLongPtr"  to asTo[2]
        Move "SetClassLong"     to asFrom[3]
        Move "SetClassLongPtr"  to asTo[3]

        // sOverstrikeLine is the LEFT-trimmed, masked line (indentation is held separately
        // in sIndentation). Re-attach it so the masked line is position-aligned with the
        // full sLine before the rename.
        Move (TokenizerData.sIndentation + TokenizerData.sOverstrikeLine) to sOverFull
        Get _RenameMaskedCalls sLine sOverFull asFrom asTo to sNewLine
        If (sNewLine = sLine) Begin
            Function_Return False
        End
        Move sNewLine to sLine
        Function_Return True
    End_Function

// NOTE: Do *not* add any code after this "End_Object"!
//       It will be removed by the JSON Export/Import logic.
End_Object