<<>> <> <> <> <> <> <> <> <> DIRECTORY AdobeCommon USING [AddToOtherQLList, AddToSet, ButtonSeqObject, EnumeratedTypesRec, GetNextAR, GrowSet, Handle, InitialSetStatus, PostMessage, SetStatus, StringArray], AdobeCommonInternal USING [InstanceDataHandle, InstanceData], AdobeOps USING [ARNumber, ARSystemHandle, QLHandle, QueryList, QueryListBody, SetOfARs, SetOfARsObject], AdobeTool, AccessCH USING [NSNameFromRope], Buttons USING [ButtonProc], Convert USING [CardFromRope, RopeFromCard, RopeFromChar], IO USING [Close, EndOfStream, GetChar, PutChar, PutRope, STREAM], PFS USING [Error, PathFromRope, StreamOpen], Rope USING [Concat, Equal, Fetch, Length, ROPE], XNSAdobeClientOps USING [ReadLastARNumber]; AdobeToolImplC: CEDAR MONITOR IMPORTS AdobeCommon, AccessCH, Convert, IO, PFS, Rope, XNSAdobeClientOps EXPORTS AdobeTool = { <> unionPos: CARDINAL = 0; intsctnPos: CARDINAL = 1; compPos: CARDINAL = 2; diffPos: CARDINAL = 3; xorPos: CARDINAL = 4; copyToListPos: CARDINAL = 5; copyToFilePos: CARDINAL =6; op1Pos: CARDINAL = 7; op2Pos: CARDINAL = 8; resultPos: <> CARDINAL = 9;--used in QLNameHints in AdobeCommonImplE nQLParams: CARDINAL = 10; backStr: Rope.ROPE Ź NIL; <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> SetUpQueryListTool: PUBLIC PROCEDURE [handle: AdobeCommon.Handle] = { handle.fieldViewer.buttons Ź NEW[AdobeCommon.ButtonSeqObject[1]]; handle.fieldViewer.buttons[0] Ź NEW[AdobeCommon.EnumeratedTypesRec]; handle.fieldViewer.buttons[0].button Ź handle.makeButton[ x: 3, y: 5, name: "List: ", scrollable: FALSE, parent: handle.fieldViewer.outer, --border: FALSE-- proc: $ListAction, data: handle, cData: handle, paint: TRUE]; handle.editors[4] Ź handle.newFieldBox[ parent: handle.fieldViewer.outer, x: 3 + handle.getBoxGeometry[handle.fieldViewer.buttons[0].button].w, y: 6, w: 400, h: 800, scrollable: FALSE, border: FALSE]; }; <> <> <> <> <> <> < {>> <> <> <> <> <<--z: windowData.heap--];>> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<--z: windowData.heap, inHeap: TRUE--];>> <> <> <> <<--z: windowData.heap, inHeap: TRUE--];>> <> <> <> <<--z: windowData.heap, inHeap: TRUE--];>> <<};>> < ERROR; --shouldn't happen>> <<};>> <<>> QLNameHintsForQueryList: PUBLIC Buttons.ButtonProc = { <> arSH: AdobeOps.ARSystemHandle; data: AdobeCommon.Handle Ź NARROW[clientData]; --AdobeCommon.GetDataSW[sw]; hintsLength, hintsIndex: CARDINAL Ź 0; hintSeq: REF AdobeCommon.StringArray; list: AdobeOps.QLHandle; CountOtherQLs: PROCEDURE RETURNS [count: CARDINAL Ź 0] = BEGIN list: AdobeOps.QLHandle Ź arSH.otherQLs; WHILE list # NIL DO count Ź count + 1; list Ź list.next; ENDLOOP; END; <> <> arSH Ź data.systemHandle; <> <> hintsLength Ź CountOtherQLs[]; hintsLength Ź hintsLength + 3; hintsIndex Ź 3; hintSeq Ź NEW[AdobeCommon.StringArray[hintsLength]]; hintSeq[0] Ź "SysQL"; hintSeq[1] Ź "List"; hintSeq[2] Ź "filename"; list Ź arSH.otherQLs; WHILE list # NIL DO hintSeq[hintsIndex] Ź list.qL.name; hintsIndex Ź hintsIndex + 1; list Ź list.next; ENDLOOP; <> }; <> <> <> <> <> <> < {>> <> <> <> <> <> < ERROR; --shouldn't happen>> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<--sw, item, index, --windowData, ChooseQLCmd]}--};>> <<};>> ChooseQLCmd: PUBLIC PROCEDURE [windowData: AdobeCommon.Handle, index: CARD] = { <> <> { ENABLE UNWIND => windowData.isBusy Ź FALSE; windowData.isBusy Ź TRUE; <> SELECT index FROM unionPos => ORSets[windowData]; intsctnPos => ANDSets[windowData]; copyToListPos => CopySet[windowData, FALSE]; copyToFilePos => CopySet[windowData, TRUE]; compPos => ComplementSet[windowData]; diffPos => DifferenceOfSets[windowData]; xorPos => XORSets[windowData]; ENDCASE => ERROR; windowData.isBusy Ź FALSE; <> AdobeCommon.PostMessage[windowData, TRUE, "Done. "] <<}>> <> }; }; NotDoneYet: PROCEDURE [windowData: AdobeCommon.Handle] = BEGIN AdobeCommon.PostMessage[windowData, TRUE, "Not Done Yet. "]; END; ORSets: PROCEDURE[data: AdobeCommon.Handle] = BEGIN set1, set2, resultSet: AdobeOps.SetOfARs Ź NIL; AdobeCommon.PostMessage[data, FALSE, "Taking Union ... "]; set1 Ź GetSetOne[data]; set2 Ź GetSetTwo[data]; <> <> resultSet Ź OrSetsImplB[set1, set2]; StoreQLinQueryList[data, resultSet]; END; --of ORSets ANDSets: PROCEDURE[data:AdobeCommon.Handle] = BEGIN set1, set2, resultSet: AdobeOps.SetOfARs Ź NIL; AdobeCommon.PostMessage[data, FALSE, "Taking Intersection ... "]; set1 Ź GetSetOne[data]; set2 Ź GetSetTwo[data]; <> <> resultSet Ź AndSetsImplB[set1, set2]; StoreQLinQueryList[data, resultSet]; END; --of ANDSets CopySet: PROCEDURE [data: AdobeCommon.Handle, toFile: BOOLEAN] = { <> <> <> <> sH: IO.STREAM; <> <> set: AdobeOps.SetOfARs Ź NIL; instanceData:AdobeCommonInternal.InstanceDataHandle Ź NARROW[data.instanceData]; <> <

>
            AdobeCommon.PostMessage[data, FALSE, "Copying ... "];
            set Ź GetSetOne[data];
            WITH instanceData SELECT FROM
                queryListData: REF AdobeCommonInternal.InstanceData.queryList => {
                    queryListData.result Ź data.getContents[data.editors[3]];
                    IF Rope.Equal[queryListData.result, "list", FALSE] THEN {
                    <>
                    <>
                        StoreQLinFileOrList[set, NIL, data];
                        data.setContents[data.editors[4], queryListData.list];
                        AdobeCommon.PostMessage[data, TRUE, "copying to List. "];
                    <>
                    <>
                        }
                    ELSE IF Rope.Equal[queryListData.result, "sysql", FALSE] THEN {
                        AdobeCommon.PostMessage[data, TRUE, "copying to SysQL. "];
                        IF data.systemHandle.sysQL = NIL THEN 
                            data.systemHandle.sysQL Ź NEW[AdobeOps.QueryListBody];
                        data.systemHandle.sysQL.list Ź set}
                    ELSE { 
                        IF ~toFile THEN StoreQLinQueryList[data, set] 
                        ELSE {
                            sH Ź PFS.StreamOpen[PFS.PathFromRope[queryListData.result], write !
                                PFS.Error => {
                                    AdobeCommon.PostMessage[data, FALSE, " ERROR--"];
                                    IF queryListData.result =NIL OR queryListData.result.Length = 0 THEN
                                        AdobeCommon.PostMessage[data, FALSE, "no file specified in result field"]
                                    ELSE {
                                        AdobeCommon.PostMessage[data, FALSE, queryListData.result];                AdobeCommon.PostMessage[data, FALSE, 
                                            " in result field"]};
                                    AdobeCommon.PostMessage[data, TRUE, " cannot be obtained."];
                                    ERROR ABORTED}];
                        <>
                        < {>>
                        <>
                        <>
                        <>
                        <>
                        <>
                        <<" in result field"]};>>
                        <>
                        <>
                            StoreQLinFileOrList[set, sH, data];
                            sH Ź CleanUpStream[sH]}}};
                    ENDCASE => ERROR;  --shouldn't happen
            }; --of CopySet

        ComplementSet:  PROCEDURE [data: AdobeCommon.Handle] =
            BEGIN
            setIndex, tempIndex: CARDINAL Ź 0;
            ARNumber, lastAR: AdobeOps.ARNumber Ź 0;
            set, tempSet, resultSet: AdobeOps.SetOfARs Ź NIL;
            system: Rope.ROPE Ź data.systemHandle.name;
        <>
        <>
            AdobeCommon.PostMessage[data, FALSE, "Complementing sets ..."];
            lastAR Ź XNSAdobeClientOps.ReadLastARNumber[data.systemHandle.service, AccessCH.NSNameFromRope[system].local];

            set Ź GetSetOne[data];

            IF set = NIL THEN {
                tempSet Ź NEW[AdobeOps.SetOfARsObject[1]];
                tempSet[0] Ź [1, lastAR];
                StoreQLinQueryList[data, tempSet];
                RETURN}
            ELSE {
                tempSet Ź NEW[AdobeOps.SetOfARsObject[set.len + 1]];
            <>
                FOR i: CARDINAL IN [0..tempSet.len) DO
                    tempSet[i] Ź [0,0];
                ENDLOOP};
            IF set[setIndex].startValue # 1 THEN {
                tempSet[tempIndex].startValue Ź 1;
                IF set[setIndex].startValue <= lastAR THEN 
                    tempSet[tempIndex].runLength Ź set[setIndex].startValue - 1
                ELSE tempSet[tempIndex].runLength Ź lastAR;
                tempIndex Ź tempIndex + 1};
            WHILE setIndex < set.len DO 
                ARNumber Ź set[setIndex].startValue + set[setIndex].runLength;
                IF ARNumber >= lastAR + 1 THEN EXIT;     
                tempSet[tempIndex].startValue Ź ARNumber;
                setIndex Ź setIndex + 1;
                IF setIndex < set.len THEN 
                    IF set[setIndex].startValue = lastAR THEN 
                        tempSet[tempIndex].runLength Ź lastAR - tempSet[tempIndex].startValue
                    ELSE IF set[setIndex].startValue > lastAR THEN 
                        tempSet[tempIndex].runLength Ź lastAR - tempSet[tempIndex].startValue + 1
                    ELSE tempSet[tempIndex].runLength Ź set[setIndex].startValue - ARNumber
                ELSE  tempSet[tempIndex].runLength Ź lastAR - ARNumber + 1;
                tempIndex Ź tempIndex + 1;
            ENDLOOP;
        <>
            resultSet Ź PruneQL[tempSet, tempIndex - 1];
            StoreQLinQueryList[data, resultSet];

            END;--of ComplementSet

        DifferenceOfSets: PROCEDURE [data:AdobeCommon.Handle]  =
            BEGIN
        <>
            ar1, ar2: AdobeOps.ARNumber Ź 0;
            set1, set2: AdobeOps.SetOfARs Ź NIL;
            set1Status, set2Status: AdobeCommon.SetStatus Ź AdobeCommon.InitialSetStatus;
            resultState: CARDINAL Ź 0;
            resultSet, tempSet: AdobeOps.SetOfARs Ź NIL;

            AdobeCommon.PostMessage[data, FALSE, "Taking difference ... "];
            set1 Ź GetSetOne[data];
            set2 Ź GetSetTwo[data];

            IF set1 = NIL THEN {StoreQLinQueryList[data, NIL]; RETURN}; 
            IF set2 = NIL THEN {StoreQLinQueryList[data, set1]; RETURN}; 
            tempSet Ź NEW[AdobeOps.SetOfARsObject[set1.len]];
            [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status];
            [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
        <>
            FOR i: CARDINAL IN [0..tempSet.len) DO
                tempSet[i] Ź [0,0];
                ENDLOOP;
        <>
        <>
        <>
            WHILE set1Status.setIndex < set1.len AND set2Status.setIndex < set2.len DO
                SELECT TRUE FROM
                    ar1 = ar2 => {
                        [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                        [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status]};
                    ar1 > ar2 => 
                        [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                    ar1 < ar2 => {
                        resultState Ź AdobeCommon.AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                        [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status]};
                    ENDCASE;      
                ENDLOOP;

        <>
            WHILE set1Status.setIndex < set1.len DO
                resultState Ź AdobeCommon.AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status];
            ENDLOOP;

        <>
            resultSet Ź PruneQL[tempSet, resultState];
            StoreQLinQueryList[data, resultSet];

            END;  -- of DifferenceOfSets


        XORSets: PROCEDURE[data: AdobeCommon.Handle]  =
            BEGIN
    <>
        ar1, ar2: AdobeOps.ARNumber Ź 0;
        set1,set2: AdobeOps.SetOfARs Ź NIL;
        set1Status, set2Status: AdobeCommon.SetStatus Ź AdobeCommon.InitialSetStatus;
        resultState: CARDINAL Ź 0;
        resultSet, tempSet: AdobeOps.SetOfARs Ź NIL;
        AdobeCommon.PostMessage[data, FALSE, "XORing sets ..."];
        set1 Ź GetSetOne[data];
        set2 Ź GetSetTwo[data];

        IF set1 = NIL THEN {StoreQLinQueryList[data, set2]; RETURN}; 
        IF set2 = NIL THEN {StoreQLinQueryList[data, set1]; RETURN}; 
        tempSet Ź NEW[AdobeOps.SetOfARsObject[set1.len + set2.len]];
    <>
        FOR i: CARDINAL IN [0..tempSet.len) DO
            tempSet[i] Ź [0,0];
            ENDLOOP;
        [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status];
        [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
        WHILE set1Status.setIndex < set1.len AND set2Status.setIndex < set2.len DO
            SELECT TRUE FROM
                ar1 = ar2 => { 
                    [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                    [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status]};
                ar1 > ar2 => {
                    resultState Ź AdobeCommon.AddToSet[ar2, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                    [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status]};
                ar1 < ar2 => {
                    resultState Ź AdobeCommon.AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                    [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status]};
                ENDCASE;
            ENDLOOP;
            WHILE set1Status.setIndex < set1.len DO
                resultState Ź AdobeCommon.AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status];
                ENDLOOP;
            WHILE set2Status.setIndex < set2.len DO
                resultState Ź AdobeCommon.AddToSet[ar2, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                ENDLOOP;

        <>
            resultSet Ź PruneQL[tempSet, resultState];
            StoreQLinQueryList[data, resultSet];

        END;  --of XORSets


        GetSetOne: PROCEDURE[data:AdobeCommon.Handle] RETURNS[set1: AdobeOps.SetOfARs Ź NIL] =
        BEGIN
        qlH: AdobeOps.QLHandle Ź NIL;
        instanceData: AdobeCommonInternal.InstanceDataHandle Ź NARROW[data.instanceData]; 
        WITH instanceData SELECT FROM
            queryListData: REF AdobeCommonInternal.InstanceData.queryList => {
                queryListData.operand1 Ź data.getContents[data.editors[1]];
                SELECT TRUE FROM
                queryListData.operand1 = NIL OR queryListData.operand1.Length = 0 => {
                    AdobeCommon.PostMessage[data, TRUE, "sysQL will be used for operand1. "];
                    IF data.systemHandle.sysQL = NIL THEN RETURN[NIL]
                    ELSE RETURN[data.systemHandle.sysQL.list]}; 
                Rope.Equal[queryListData.operand1, "list", FALSE] => {
                    set1 Ź GetList[data];
                    RETURN[set1]};
                Rope.Equal[queryListData.operand1, "sysQL", FALSE] => {
                    IF data.systemHandle.sysQL = NIL THEN RETURN[NIL]
                    ELSE RETURN[data.systemHandle.sysQL.list]};
                ENDCASE => {
                    qlH Ź data.systemHandle.otherQLs;
                    WHILE qlH # NIL DO
                        IF Rope.Equal[queryListData.operand1, qlH.qL.name, FALSE] THEN
                            RETURN[qlH.qL.list];
                        qlH Ź qlH.next;
                    ENDLOOP;
                <>
                <>
                    RETURN[RetrieveQL[queryListData.operand1, data]]}; 
                }; 
            ENDCASE;  --shouldn't happen;
        END; --of GetSetOne

        GetSetTwo: PROCEDURE [data: AdobeCommon.Handle] RETURNS[set2:     AdobeOps.SetOfARs] =
            BEGIN
            qlH:AdobeOps.QLHandle Ź NIL;
            instanceData: AdobeCommonInternal.InstanceDataHandle Ź NARROW[data.instanceData];
        WITH instanceData SELECT FROM
            queryListData: REF AdobeCommonInternal.InstanceData.queryList => {
                queryListData.operand2 Ź data.getContents[data.editors[2]];
                SELECT TRUE FROM
                queryListData.operand2 = NIL OR queryListData.operand2.Length = 0 => {
                    AdobeCommon.PostMessage[
                        data, TRUE, "sysQL will be used for operand2. "];
                    IF data.systemHandle.sysQL = NIL THEN RETURN[NIL]
                    ELSE RETURN[data.systemHandle.sysQL.list]};
                Rope.Equal[queryListData.operand2, "list", FALSE] => {
                    set2 Ź GetList[data];
                    RETURN[set2]};
                Rope.Equal[queryListData.operand2, "sysQL", FALSE] => {
                    <>
                    IF data.systemHandle.sysQL = NIL THEN RETURN[NIL]
                    ELSE RETURN[data.systemHandle.sysQL.list]};
                ENDCASE => {
                    qlH Ź data.systemHandle.otherQLs;
                    WHILE qlH # NIL DO
                        IF Rope.Equal[queryListData.operand2, qlH.qL.name, FALSE] THEN
                            RETURN[qlH.qL.list];
                        qlH Ź qlH.next;
                    ENDLOOP;
                <>
                <>
                    RETURN[RetrieveQL[queryListData.operand2, data]]};  
                };
            ENDCASE;  --shouldn't happen;
        END; --of GetSetTwo

        GetList: PROCEDURE [data:AdobeCommon.Handle]  RETURNS [resultSet: AdobeOps.SetOfARs Ź NIL] =
            BEGIN
            qlH:AdobeOps.QLHandle Ź NIL;
            setIndex: CARDINAL Ź 0;
            listIndex: INTEGER Ź 0;
            arNumberString: Rope.ROPE Ź NIL;
            arNumber, prevarNumber: AdobeOps.ARNumber Ź 0;
            set: AdobeOps.SetOfARs Ź NIL;
            instanceData: AdobeCommonInternal.InstanceDataHandle Ź NARROW[data.instanceData];

            BEGIN ENABLE {
                UNWIND => {
                IF arNumberString # NIL THEN arNumberString Ź NIL;
                IF set # NIL THEN set Ź NIL } };
                <>

            GetAR: PROCEDURE[list: Rope.ROPE] =
                BEGIN
                arNumber Ź 0;
                WHILE listIndex < list.Length AND list.Fetch[listIndex] = '  DO
                    listIndex Ź listIndex + 1;
                ENDLOOP;
                IF listIndex < list.Length AND list.Fetch[listIndex] NOT IN ['0..'9] AND list.Fetch[listIndex] # '- THEN {
                    AdobeCommon.PostMessage[data, TRUE, "Invalid character entered in List."];
                    ERROR ABORTED};
                WHILE listIndex < list.Length AND list.Fetch[listIndex] IN ['0..'9] DO
                    arNumberString Ź arNumberString.Concat[Convert.RopeFromChar[list.Fetch[listIndex], FALSE]];
                    <>
                    listIndex Ź listIndex + 1;
                ENDLOOP;
                IF listIndex < list.Length AND list.Fetch[listIndex] # '  AND list.Fetch[listIndex] # '- THEN {
                    AdobeCommon.PostMessage[data, TRUE, "Invalid character entered in List."];
                    ERROR ABORTED};
                IF arNumberString.Length #0 THEN {
                    arNumber Ź Convert.CardFromRope[arNumberString];
                    IF arNumber = 0 THEN {
                        AdobeCommon.PostMessage[data, TRUE, "AR number 0 is invalid"];
                        ERROR ABORTED}};
                arNumberString Ź ClearString[arNumberString];
                WHILE listIndex < list.Length AND list.Fetch[listIndex] = '  DO
                    listIndex Ź listIndex + 1;
                ENDLOOP; 
                IF listIndex < list.Length AND list.Fetch[listIndex] NOT IN ['0..'9] AND list.Fetch[listIndex] # '- THEN {
                    AdobeCommon.PostMessage[data, TRUE, "Invalid character entered in List."];
                    ERROR ABORTED};     
                END;--of GetAR


            WITH instanceData SELECT FROM
                queryListData:  REF AdobeCommonInternal.InstanceData.queryList => {
                    queryListData.list Ź data.getContents[data.editors[4]];
                    IF queryListData.list = NIL OR queryListData.list.Length = 0 THEN RETURN[NIL];
                <>
                    set Ź NEW[AdobeOps.SetOfARsObject[10]];
                <>
                    FOR i: CARDINAL IN [0..set.len) DO
                        set[i] Ź [0,0];
                    ENDLOOP; 
                    WHILE listIndex < queryListData.list.Length DO
                        GetAR[queryListData.list];
                    SELECT TRUE FROM
                        prevarNumber = 0 AND arNumber = 0 =>  AdobeCommon.PostMessage[data, TRUE, "List is empty or invalid list format.  An empty query 
                        list has been created"];
                        prevarNumber > arNumber AND arNumber # 0 =>  {                              AdobeCommon.PostMessage[data, TRUE, "The numbers 
                        entered in list should be in ascending order."];
                            ERROR ABORTED};
                        prevarNumber = arNumber => {
                            AdobeCommon.PostMessage[data, TRUE, "Duplicate numbers."];
                            ERROR ABORTED};
                        ENDCASE;
                        prevarNumber Ź arNumber;
                        IF set[setIndex].startValue + set[setIndex].runLength = arNumber THEN
                            set[setIndex].runLength Ź set[setIndex].runLength + 1
                        ELSE  {
                            IF set[setIndex].startValue # 0 THEN {
                                setIndex Ź setIndex + 1;
                                IF setIndex = set.len THEN AdobeCommon.GrowSet[NEW[AdobeOps.SetOfARs Ź set]]};
                            set[setIndex].startValue Ź arNumber;
                            set[setIndex].runLength Ź 1};

                        IF listIndex < queryListData.list.Length AND queryListData.list.Fetch[listIndex] = '- THEN {
                            listIndex Ź listIndex + 1;
                            GetAR[queryListData.list];
                            IF prevarNumber > arNumber AND arNumber # 0 THEN {                                     AdobeCommon.PostMessage[data, TRUE, "The 
                            numbers entered in list should be in ascending order."];
                                ERROR ABORTED};
                            set[setIndex].runLength Ź arNumber - set[setIndex].startValue + 1};
                    ENDLOOP};
                ENDCASE;
                resultSet Ź PruneQL[set, setIndex];
            END; --enable
            END;--of GetList

        OrSetsImplB: PROCEDURE [set1, set2: AdobeOps.SetOfARs]
            RETURNS [resultSet: AdobeOps.SetOfARs] =
            BEGIN
        <>
        <>
            ar1, ar2: AdobeOps.ARNumber;
            set1Status, set2Status: AdobeCommon.SetStatus Ź [0, 0];
            resultState: CARDINAL Ź 0;
            tempSet: AdobeOps.SetOfARs;
            IF set1 = NIL THEN RETURN[set2];
            IF set2 = NIL THEN RETURN[set1];
            tempSet Ź NEW[
                AdobeOps .SetOfARsObject[set1.len + set2.len]];
            ar1 Ź set1[0].startValue;
            ar2 Ź set2[0].startValue;
        <>
            FOR i: CARDINAL IN [0..tempSet.len) DO
                tempSet[i] Ź [0, 0]; ENDLOOP;
        <>
        <>
            WHILE set1Status.setIndex < set1.len
                AND set2Status.setIndex < set2.len DO
                SELECT TRUE FROM
                    ar1 = ar2 => {  --add only once
                        resultState Ź AdobeCommon.AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                        [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                        [ar1, set1Status] Ź AdobeCommon.GetNextAR[
                            set1, set1Status]};
                    ar1 > ar2 => {
                        resultState Ź AdobeCommon.AddToSet[ar2, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                        [ar2, set2Status] Ź AdobeCommon.GetNextAR[
                            set2, set2Status]};
                    ar1 < ar2 => {
                        resultState Ź AdobeCommon.AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                        [ar1, set1Status] Ź AdobeCommon.GetNextAR[
                            set1, set1Status]};
                    ENDCASE;
                ENDLOOP;
            IF set1Status.setIndex < set1.len THEN  --add rest of set1
                WHILE set1Status.setIndex < set1.len DO
                    resultState Ź AdobeCommon.AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                    [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status];
                    ENDLOOP
            ELSE  --add rest of set2
                WHILE set2Status.setIndex < set2.len DO
                    resultState Ź AdobeCommon.AddToSet[ar2, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                    [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                    ENDLOOP;
            IF resultState + 1 = (set1.len + set2.len) THEN {
            <>
            <>
                RETURN[tempSet]}
            ELSE {
                resultSet Ź NEW[
                    AdobeOps .SetOfARsObject[resultState + 1]];
                FOR i: CARDINAL IN [0..resultSet.len) DO
                    resultSet[i] Ź tempSet[i]; ENDLOOP;
            <>
                };
            <>
            <>
            END;

        AndSetsImplB: PROCEDURE [set1, set2: AdobeOps.SetOfARs]
            RETURNS [resultSet: AdobeOps.SetOfARs] =
            BEGIN
        <>
        <>
        <>
            ar1, ar2: AdobeOps.ARNumber;
            set1Status, set2Status: AdobeCommon.SetStatus Ź
                AdobeCommon.InitialSetStatus;
            resultState: CARDINAL Ź 0;
            tempSet: AdobeOps.SetOfARs;
            IF set1 = NIL THEN {
                IF set2 # NIL THEN set2 Ź NIL;
                <>
                RETURN[NIL]}
            ELSE IF set2 = NIL THEN {
                set1 Ź NIL;
            <>
                RETURN[NIL]};
            tempSet Ź NEW[
                AdobeOps .SetOfARsObject[MAX[set1.len, set2.len]]];
            [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status];
            [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
        <>
            FOR i: CARDINAL IN [0..tempSet.len) DO
                tempSet[i] Ź [0, 0]; ENDLOOP;
        <>
        <>
            WHILE set1Status.setIndex < set1.len
                AND set2Status.setIndex < set2.len DO
                SELECT TRUE FROM
                    ar1 = ar2 => {
                        resultState Ź AdobeCommon.AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                        [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                        [ar1, set1Status] Ź AdobeCommon.GetNextAR[
                            set1, set1Status]};
                    ar1 > ar2 =>
                        [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                    ar1 < ar2 =>
                        [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status];
                    ENDCASE;
                ENDLOOP;
            IF resultState = 0 AND tempSet[0].startValue = 0 THEN {  --empty set
            <>
            <>
            <>
                RETURN[NIL]};
        <>
            IF resultState + 1 = MAX[set1.len, set2.len] THEN {
            <>
            <>
                RETURN[tempSet]}
            ELSE {
                resultSet Ź NEW[
                    AdobeOps .SetOfARsObject[resultState + 1]];
                FOR i: CARDINAL IN [0..resultSet.len) DO
                    resultSet[i] Ź tempSet[i]; ENDLOOP;
            <>
                };
            <>
            <>
            END;


        RetrieveQL: PROCEDURE[fileName: Rope.ROPE, data:AdobeCommon.Handle] RETURNS [resultSet: AdobeOps.SetOfARs Ź NIL] =
    <>
        BEGIN

    <>
        fH: IO.STREAM Ź NIL;
    <>
    <>
        char: CHARACTER Ź ' ;
        prevARNumber, arNumber: AdobeOps.ARNumber Ź 0;
        arNumberString: Rope.ROPE Ź NIL;
        tempSet: AdobeOps.SetOfARs Ź NIL;
        tempIndex: CARDINAL Ź 0;
        endOfFile: BOOLEAN Ź FALSE;

        BEGIN ENABLE {
            UNWIND => {
                IF fH # NIL THEN IO.Close[fH];
                <>
                IF arNumberString # NIL THEN arNumberString Ź NIL;
                IF tempSet # NIL THEN tempSet Ź NIL}};
                <>


            GetNextARNumber: PROCEDURE  =
                BEGIN
                WHILE char = ' DO
                    char Ź IO.GetChar[fH !IO.EndOfStream => GOTO EOF];
                    ENDLOOP;
                WHILE char IN ['0..'9] AND NOT endOfFile DO
                    arNumberString Ź arNumberString.Concat[Convert.RopeFromChar[char, FALSE]];
                    <>
                    char Ź IO.GetChar[fH !IO.EndOfStream => GOTO EOF];
                ENDLOOP;
                WHILE char = ' DO
                    char Ź IO.GetChar[fH !IO.EndOfStream => GOTO EOF];
                    ENDLOOP;
                IF char NOT IN ['0..'9] AND  char # '- THEN {
                    AdobeCommon.PostMessage[data, TRUE, "Invalid character in file!  ."];
                    ERROR ABORTED};
                prevARNumber Ź arNumber;
                IF arNumberString.Length = 0 THEN {
                    AdobeCommon.PostMessage[data, TRUE, "Invalid syntax!  ."];
                    ERROR ABORTED};
                arNumber Ź Convert.CardFromRope[arNumberString];
                arNumberString Ź ClearString[arNumberString];
                IF arNumber <= prevARNumber THEN {
                    AdobeCommon.PostMessage[data, TRUE, "AR numbers must be in ascending order!  ."];
                    ERROR ABORTED}
                EXITS
                    EOF => {
                        IF arNumberString.Length # 0 THEN {
                            prevARNumber Ź arNumber;
                            arNumber Ź Convert.CardFromRope[arNumberString];
                            IF arNumber <= prevARNumber THEN {
                                AdobeCommon.PostMessage[
                                    data, TRUE, "AR numbers must be in ascending order!  ."];
                                ERROR ABORTED};
                            arNumberString Ź ClearString[arNumberString]};
                        endOfFile Ź TRUE;}

                END; --of GetNextARNumber


    <>
        fH Ź PFS.StreamOpen[PFS.PathFromRope[fileName] ! PFS.Error =>
            {AdobeCommon.PostMessage[data, FALSE, fileName];
                AdobeCommon.PostMessage[data, TRUE, " does not exist as a querylist or file."];
                ERROR ABORTED}];
    <>>
    <<{AdobeCommon.PostMessage[data, FALSE, fileName];>>
    <>
    <>
    <>
        tempSet Ź NEW[AdobeOps.SetOfARsObject[100]];
    <>
        FOR i: CARDINAL IN [0..tempSet.len) DO
            tempSet[i] Ź [0,0];
        ENDLOOP;

        GetNextARNumber[];
        tempSet[0].startValue Ź arNumber;
        IF endOfFile OR char IN ['0..'9] THEN
            tempSet[0].runLength Ź 1
        ELSE IF NOT endOfFile AND char = '- THEN {
            char Ź IO.GetChar[fH !IO.EndOfStream => {
                AdobeCommon.PostMessage[data, TRUE, "Invalid Syntax!  ."];
                ERROR ABORTED}];
            GetNextARNumber[];
            tempSet[0].runLength Ź arNumber - tempSet[0].startValue + 1};
        WHILE NOT endOfFile DO
            GetNextARNumber[];
            IF arNumber # tempSet[tempIndex].startValue + tempSet[tempIndex].runLength         THEN{ 
                tempIndex Ź tempIndex + 1;
                IF tempIndex = tempSet.len THEN AdobeCommon.GrowSet[NEW[AdobeOps.SetOfARs Ź tempSet]];
                tempSet[tempIndex].startValue Ź arNumber;
                IF endOfFile OR char IN ['0..'9]  THEN
                    tempSet[tempIndex].runLength Ź 1
                ELSE IF NOT endOfFile AND char = '- THEN {
                    char Ź IO.GetChar[fH !IO.EndOfStream => {
                        AdobeCommon.PostMessage[data, TRUE, "Invalid Syntax!  ."];
                        ERROR ABORTED}];
                    GetNextARNumber[];
                    tempSet[tempIndex].runLength Ź 
                        arNumber - tempSet[tempIndex].startValue + 1}}
                ELSE {
                    IF endOfFile OR char IN ['0..'9] THEN
                        tempSet[tempIndex].runLength Ź tempSet[tempIndex].runLength + 1
                    ELSE IF NOT endOfFile AND char = '- THEN {
                        char Ź IO.GetChar[fH !IO.EndOfStream => {
                            AdobeCommon.PostMessage[data, TRUE, "Invalid Syntax!  ."];
                            ERROR ABORTED}];
                        GetNextARNumber[];
                        tempSet[tempIndex].runLength Ź 
                            arNumber - tempSet[tempIndex].startValue + 1;}}
        ENDLOOP;

        fH Ź CleanUpStream[fH];
        arNumberString Ź NIL;
        <>

    <>
        resultSet Ź PruneQL[tempSet, tempIndex]

        END;
        END; --of RetrieveQL

        StoreQLinQueryList: PROCEDURE[data: AdobeCommon.Handle, set: AdobeOps.SetOfARs] = {

            found: BOOLEAN Ź FALSE;
            qlH: AdobeOps.QLHandle Ź NIL;
            ql: AdobeOps.QueryList Ź NIL;
            instanceData: AdobeCommonInternal.InstanceDataHandle Ź NARROW[data.instanceData];
        <>
            WITH instanceData SELECT FROM
                queryListData: REF AdobeCommonInternal.InstanceData.queryList => {
                    queryListData.result Ź data.getContents[data.editors[3]];
                    IF queryListData.result = NIL OR queryListData.result.Length = 0 THEN 
                        AdobeCommon.PostMessage[
                            data, TRUE, "ERROR--result field not specified."]
                    ELSE IF Rope.Equal[queryListData.result, "SysQL", FALSE] THEN {
                        IF data.systemHandle.sysQL = NIL THEN 
                            data.systemHandle.sysQL Ź NEW[AdobeOps.QueryListBody];
                        data.systemHandle.sysQL.list Ź set}
                    ELSE IF Rope.Equal[queryListData.result, "List", FALSE] THEN {
                    <>
                    <>
                        StoreQLinFileOrList[set, NIL, data];
                    <>
                    <>
                        }
                    ELSE {
                        qlH Ź data.systemHandle.otherQLs;
                        WHILE qlH # NIL AND found = FALSE DO
                            IF Rope.Equal[queryListData.result, qlH.qL.name, FALSE] THEN
                                found Ź TRUE
                            ELSE qlH Ź qlH.next;
                        ENDLOOP;
                        IF found THEN qlH.qL.list Ź set
                        ELSE {
                            ql Ź NEW[AdobeOps.QueryListBody];
                            ql.name Ź queryListData.result;
                            ql.list Ź set;
                            AdobeCommon.AddToOtherQLList[data.systemHandle, ql]}}};
                ENDCASE; --shoud not happen

            };--of StoreQLinQueryList

        StoreQLinFileOrList: PROCEDURE[set: AdobeOps.SetOfARs, fH: IO.STREAM, data: AdobeCommon.Handle] =
            BEGIN
            beginValue, runValue, endValue: AdobeOps.ARNumber Ź 0;
            stringValue: Rope.ROPE ŹNIL;
            hyphen: CHARACTER Ź '-;
            space: CHARACTER Ź ' ;
            copyToList: BOOLEAN Ź FALSE;
            instanceData: AdobeCommonInternal.InstanceDataHandle Ź NARROW[data.instanceData];
            WITH instanceData SELECT FROM
                queryListData: REF AdobeCommonInternal.InstanceData.queryList => {
                    IF fH = NIL THEN {
                        copyToList Ź TRUE; 
                        IF queryListData.list # NIL THEN
                            queryListData.list Ź NIL;
                        <>
                        <>
                            };
                    IF set # NIL THEN 
                        BEGIN
                    <>
                        FOR index:CARDINAL IN [0..set.len) DO
                            beginValue Ź set[index].startValue;
                            stringValue Ź ClearString[stringValue];
                            stringValue Ź stringValue.Concat[Convert.RopeFromCard[beginValue, 10, FALSE]];
                            <>
                            IF copyToList THEN queryListData.list Ź queryListData.list.Concat[stringValue]
                            ELSE IO.PutRope[fH, stringValue];
                            runValue Ź set[index].runLength;
                            IF runValue = 1 AND index # set.len - 1 THEN 
                                IF copyToList THEN queryListData.list Ź queryListData.list.Concat[Convert.RopeFromChar[space, FALSE]]
                                <>
                                ELSE IO.PutChar[fH, space]
                            ELSE IF runValue # 1 THEN {
                                IF copyToList THEN queryListData.list Ź queryListData.list.Concat[Convert.RopeFromChar[hyphen, FALSE]]
                                <>
                                ELSE IO.PutChar[fH, hyphen];
                                endValue Ź beginValue + runValue -1;
                                stringValue Ź ClearString[stringValue]; 
                                stringValue Ź stringValue.Concat[Convert.RopeFromCard[endValue, 10, FALSE]];
                                <>
                                IF copyToList THEN queryListData.list Ź queryListData.list.Concat[stringValue]
                                ELSE IO.PutRope[fH, stringValue];
                                IF index # set.len - 1 THEN 
                                    IF copyToList THEN queryListData.list Ź queryListData.list.Concat[Convert.RopeFromChar[space, FALSE]]
                                    <>
                                    ELSE IO.PutChar[fH,space]};
                        ENDLOOP;
                        stringValue Ź NIL;
                        <>
                        END
                    ELSE IF ~copyToList THEN IO.PutChar[fH,space]};
                    ENDCASE;
            END;

        CleanUpStream: PROCEDURE[streamHandle: IO.STREAM--MStream.Handle--] RETURNS [--MStream.Handle-- IO.STREAM] = {
            streamHandle.Close;
            <>
            streamHandle Ź NIL;
            RETURN [streamHandle];
            }; --of CleanUpStream

        ClearString: PROCEDURE[inString: Rope.ROPE] RETURNS [Rope.ROPE Ź NIL] = {
        <>
        <>
        <>
        <>
        <>
        <>
        <>
            RETURN [NIL];
            <>
            }; --of ClearString


        PruneQL: PROCEDURE[set:AdobeOps.SetOfARs, index:CARDINAL] RETURNS [AdobeOps.SetOfARs] =
            BEGIN
            newSet: AdobeOps.SetOfARs Ź NIL;

            IF set[0].startValue = 0 THEN {
            <>
                RETURN[NIL]};
            IF index + 1 = set.len THEN RETURN[set]
            ELSE {
                newSet Ź NEW[AdobeOps.SetOfARsObject[index + 1]];
                FOR i: CARDINAL IN [0..newSet.len) DO
                    newSet[i] Ź set[i];
                ENDLOOP;
            <>
                RETURN[newSet]};
            END; --of PruneQL

        }. . .