<<>>
<<File: AdobeToolsB.mesa>>
<<Copyright Ó 1991, 1992 by Xerox Corporation.  All rights reserved.>>
<<Philip James, June 24, 1991 10:47 am PDT>>
<<Pjames, March 3, 1992 7:08 pm PST>>
<<Foote, June 24, 1992 8:42 am PDT>>

    DIRECTORY
        AccessCH USING [NSNameFromRope],
        AdobeCommon USING [AdobeViewerDataRec, ButtonSeqObject, CatchErrors, DependentsSequenceRec, EnumeratedTypes, EnumeratedTypesRec, 
        GetNextAR, Handle, InitialSetStatus, PostMessage, PostNumber, SelectionsSequence, SetStatus, StringArray, validRelations],
        AdobeCommonInternal USING [InstanceData, InstanceDataHandle],
        AdobeOps USING [ARSystemHandle, ARNumber, FieldItemObject, FieldItemObjectRec, FieldType, nilARNumber, nilEnum, QLHandle, QLObject, 
        QueryList, QueryListBody, SetOfARs, SetOfARsObject, ToolType, ArFIO, DateFIO, NumFIO, FixFIO, EnumFIO, StrFIO],
        AdobeServer USING [FieldItemValueRec, FieldItemQueryValue],
        AdobeP75V2,
        AdobeTool,
        AdobeUI,
        Ascii USING [CR, NUL, SP, TAB],
        BasicTime USING [GMT],
        Convert USING [Error, CardFromRope, RopeFromChar, TimeFromRope],
        Rope USING [Concat, Equal, Fetch, IsEmpty, Length, ROPE],
        XNSAdobeClientOps USING [LookupARs, ReadLastARNumber];


    AdobeToolImplB: CEDAR MONITOR
        IMPORTS 
        AccessCH, AdobeCommon, AdobeP75V2, AdobeTool,  Convert,  Rope, XNSAdobeClientOps
        EXPORTS 
        AdobeCommon, --AdobeCommonInternal, --AdobeTool =
        {

        EnumeratedFIH: TYPE = REF enumerated
            AdobeOps.FieldItemObjectRec;

        backStr: Rope.ROPE Ź NIL;  --for NilFormProc

    <<globals for query>>
        queryPos: CARDINAL = 0;
        clearFormPos: CARDINAL = 1;
        showElemPos: CARDINAL = 2;
        resetQLPos: CARDINAL = 3;
        qyBkgdPos: CARDINAL = 4;
        qlNamePos: CARDINAL = 5;
        nQueryParams: CARDINAL = 6;

    <<from Token>>
        UnterminatedQuote: PUBLIC SIGNAL = CODE;
        nonQuote: CHARACTER = Ascii.NUL;
        SkipMode: TYPE = {none, whiteSpace, nonToken};
        GetCharProcType: TYPE = PROCEDURE [h: LSHandle, e: REF BoolRec Ź NIL] RETURNS [c: CHARACTER];
        QuoteProcType: TYPE = PROCEDURE [c: CHARACTER] RETURNS [closing: CHARACTER];
        FilterProcType: TYPE = PROCEDURE [c: CHARACTER, data: FilterState, extra: CHAR Ź ' ] 
        RETURNS [inClass: BOOLEAN];
        FilterState: TYPE = REF StandardFilterState;
        StandardFilterState: TYPE = ARRAY [0..2) OF UNSPECIFIED;
        Handle: TYPE = REF Object;
        Object: TYPE = RECORD [
            getChar: GetCharProcType, break: CHAR Ź NULL];

        StringToHandle: PROCEDURE [s: Rope.ROPE, offset: CARDINAL Ź 0] 
        RETURNS [h: LSHandle] ~ {
            h Ź NEW[LSObject Ź [[getChar: StringGetChar, break: NULL], s, offset]]
            };

        StringGetChar: GetCharProcType ~ {
            IF h.i < Rope.Length[h.s] THEN { 
                c Ź Rope.Fetch[h.s, h.i];
                h.i Ź h.i + 1}
            ELSE c Ź Ascii.NUL;
            };


        WhiteSpaceInline: PROCEDURE [c: CHARACTER] RETURNS [BOOLEAN] = INLINE { 
            RETURN[SELECT c FROM Ascii.SP, Ascii.TAB, Ascii.CR => TRUE, ENDCASE => FALSE]; };

        QuoteFilter: FilterProcType = {
            IF c = Ascii.NUL THEN {SIGNAL UnterminatedQuote; RETURN [FALSE]}
            ELSE RETURN[c # extra]};

        MaybeQuoted: PROCEDURE [h: LSHandle, data: FilterState, filter: FilterProcType, 
        isQuote: QuoteProcType, skip: SkipMode Ź whiteSpace, temporary: BOOLEAN Ź TRUE] 
        RETURNS [value: Rope.ROPE] = {
            closeQuote: CHARACTER;
            ApplyFilter: FilterProcType Ź filter;

            IF data # NIL THEN
                data Ź NIL;

            value Ź NIL;
        <<First handle (possible) skip>>
            DO
                IF (h.object.break Ź h.object.getChar[h]) = Ascii.NUL THEN RETURN;
                IF skip = whiteSpace AND WhiteSpaceInline[h.object.break] THEN LOOP;
                IF (closeQuote Ź isQuote[h.object.break]) # nonQuote THEN
                    IF (h.object.break Ź h.object.getChar[h]) = closeQuote THEN {
                        h.object.break Ź h.object.getChar[h]; 
                        IF h.object.break = closeQuote THEN EXIT; -- doubling close quote is literal quote character
                        RETURN}
                    ELSE {
                        IF h.object.break = Ascii.NUL THEN {SIGNAL UnterminatedQuote; RETURN};
                        ApplyFilter Ź QuoteFilter; EXIT};
                IF filter[h.object.break, data] THEN EXIT;
                IF skip = none OR skip = whiteSpace THEN RETURN;
                ENDLOOP;
        <<Then accumulate all inClass characters>>
        <<value _ GetString[initialLength];>>
            {
                ENABLE 
                    UNWIND => NULL;
                WHILE h.object.break # Ascii.NUL DO
                    value Ź value.Concat[Convert.RopeFromChar[h.object.break, FALSE]];
                    <<String.AppendChar[value, h.object.break];>>
                    IF ~ApplyFilter[h.object.break Ź h.object.getChar[h], data, closeQuote] THEN {
                        IF ApplyFilter = QuoteFilter THEN {
                            h.object.break Ź h.object.getChar[h]; -- get next character
                            IF h.object.break = closeQuote THEN LOOP}; -- of closeQuote, include character in token
                        EXIT;
                        };
                        ENDLOOP;
                <<IF ~temporary THEN {>>
                <<old: Rope.ROPE _ value;>>
                <<value _ old;>>
                <<FreeString[old]};>>
                };
            };

    <<types for query>>
        ParseError: SIGNAL [errType: ParseErrorType] = CODE;  --make more specific later
        ParseErrorType: TYPE = {
            badNumber, badDate, notValidEnumerated, strayQuote,
            badQuerySyntax};
        LSHandle: TYPE = REF LSObject;
        LSObject: TYPE = RECORD [
            object: Object, s: Rope.ROPE, i: INT];
        TokenType: TYPE = {op, string, andor};
        QueryItemHandle: TYPE = REF QueryItemSeq Ź NIL;
        QueryItemSeq: TYPE = RECORD [
            fLIndex: CARDINAL, seq: SEQUENCE len: CARDINAL OF REF ANY];
        DistilledToken: TYPE = RECORD [
            SELECT type: TokenType FROM
            op => [op: AdobeP75V2.Relation],
            string => [s: Rope.ROPE],
            andor => [andOr: {and, or}]
            ENDCASE];
        OpDT: TYPE ~ REF op DistilledToken;
        StringDT: TYPE ~ REF string DistilledToken;
        AndOrDT: TYPE ~ REF andor DistilledToken;
        ParseStateType: TYPE = {start, op, andor, string, end};
        ProcessedQueryHandle: TYPE = REF ProcessedQuery;
        ProcessedQuery: TYPE = RECORD [
            seq: SEQUENCE len: CARDINAL OF QueryItemHandle];
        FieldItemHandle: TYPE = REF FieldItemSeq;
        FieldItemSeq: TYPE = RECORD [
            seq: SEQUENCE len: CARDINAL OF AdobeServer.FieldItemQueryValue];

        GetValidRelations: PUBLIC PROCEDURE [
            type: AdobeOps.FieldType]
            RETURNS [relStrings: REF AdobeCommon.StringArray] =
            {
            numValid, index: CARDINAL Ź 0;
            op: AdobeP75V2.Relation;
            FOR op IN AdobeP75V2.Relation DO
                IF AdobeCommon.validRelations[type][op] THEN
                    numValid Ź numValid + 1;
                ENDLOOP;
            IF type = enumerated THEN numValid Ź numValid + 2  --OR, AND #
            ELSE numValid Ź numValid + 3;  --OR, AND, NIL
            relStrings Ź NEW[AdobeCommon.StringArray[numValid]];
            FOR op IN AdobeP75V2.Relation DO
                IF AdobeCommon.validRelations[type][op] THEN {
                    relStrings[index] Ź 
                        SELECT op FROM
                            equal => " = ",
                            notEqual => " # ",
                            lessThan => " < ",
                            lessThanOrEqual => " <= ",
                            greaterThan => " > ",
                            greaterThanOrEqual => " >= ",
                            in => " HAS ",
                            notIn => " ~HAS ",
                            ENDCASE => "";
                    index Ź index + 1};
                ENDLOOP;
            relStrings[index] Ź " OR ";
            IF type = enumerated THEN
                relStrings[index Ź index + 1] Ź " AND # "
            ELSE {
                relStrings[index Ź index + 1] Ź " AND ";
                relStrings[index Ź index + 1] Ź " NIL "};
            };

        GetPossibilities: PUBLIC PROCEDURE [bh: AdobeCommon.EnumeratedTypes]
            RETURNS [possibilities: LIST OF Rope.ROPE] =
            {
            IF bh.currentMenu >= bh.allSelections.length THEN
                RETURN [LIST["Nil"]];
            RETURN[bh.allSelections[bh.currentMenu].ropes];
            };

        CountARs:  PUBLIC PROCEDURE [set: AdobeOps.SetOfARs]
            RETURNS [n: LONG CARDINAL] = 
            {
            n Ź 0;
            FOR i: CARDINAL IN [0..set.len) DO
                n Ź n + set[i].runLength; ENDLOOP;
            };


    <<Query routines  >>

        SetUpQueryTool: PUBLIC PROC [handle: AdobeCommon.Handle] = {
            thisViewer: REF ANY Ź handle.fieldViewer.outer;
            thisSH: AdobeOps.ARSystemHandle Ź handle.systemHandle;
            thisField: AdobeCommon.EnumeratedTypes Ź NIL;
            x,y,w,h: CARD;
            lineIndex: INTEGER Ź 0;
            fieldIndex: CARD Ź 0;
            fieldHeight: CARDINAL Ź 14;
            numFields: CARD Ź thisSH.fieldList.length;
            instanceData: AdobeCommonInternal.InstanceDataHandle Ź NARROW[handle.instanceData];
        stringCount: CARD _ 0;

            IF handle.fieldViewer.buttons # NIL THEN AdobeTool.EmptyFieldViewer[handle];

        <<don't make fields for string items >>
            FOR field: CARDINAL IN [0..thisSH.fieldList.length) DO
                WITH thisSH.fieldList[field] SELECT FROM
                    it: AdobeOps.StrFIO => numFields Ź numFields - 1;
                    ENDCASE;
                ENDLOOP;

            handle.fieldViewer.buttons Ź NEW[AdobeCommon.ButtonSeqObject[numFields]];

            WITH instanceData SELECT FROM
                it: REF AdobeCommonInternal.InstanceData.query =>
                    it.queryStrings Ź NEW[AdobeCommon.StringArray[numFields]];
                ENDCASE;

            FOR field: CARDINAL IN [0..thisSH.fieldList.length) DO
                WITH thisSH.fieldList[field] SELECT FROM
                    it: AdobeOps.StrFIO => {
                    stringCount _ stringCount + 1;
                        };
                    ENDCASE => {
                        handle.fieldViewer.buttons[fieldIndex] Ź NEW[AdobeCommon.EnumeratedTypesRec];
                        handle.fieldViewer.buttons[fieldIndex].mainViewer Ź handle;
                        };
                IF fieldIndex < handle.fieldViewer.buttons.length THEN
                    thisField Ź handle.fieldViewer.buttons[fieldIndex];
                WITH thisSH.fieldList[field] SELECT FROM
                    it: AdobeOps.EnumFIO => {
                        numSubMenus, saveKey, currentEnum: CARD Ź 0;
                        thisField.type Ź enumerated;
                        thisField.dependentsSequence Ź NEW[AdobeCommon.DependentsSequenceRec[5]];

                        IF it.field # LAST[CARD16] THEN {
                            currentSubMenu: CARD Ź 0;
                            thisField.dependentOn Ź handle.fieldViewer.buttons[it.field - stringCount];
                            numSubMenus Ź AdobeTool.CountRopes[thisField.dependentOn.allSelections[0].ropes];
                            AdobeTool.BumpNumOfDeps[handle.fieldViewer.buttons[fieldIndex], handle.fieldViewer.buttons[it.field - stringCount]];
                            thisField.currentMenu Ź numSubMenus - 1;
                            thisField.allSelections Ź NEW[AdobeCommon.SelectionsSequence[numSubMenus]];

                            WITH thisSH.fieldList[it.field] SELECT FROM
                                dep: AdobeOps.EnumFIO => {
                                    did: BOOL Ź FALSE;
                                    FOR index: CARD IN [0..dep.possibilities[0].enumRecs.length) DO
                                        did Ź FALSE;
                                        FOR itIndex: CARD IN [0..it.possibilities.length) DO
                                            IF it.possibilities[itIndex].keyedDependency = 
                                            dep.possibilities[0].enumRecs[index].item THEN {
                                                thisField.allSelections[currentSubMenu].num Ź index;
                                                FOR i: CARD IN [0..it.possibilities[itIndex].enumRecs.length) DO
                                                    thisField.allSelections[currentSubMenu].ropes Ź CONS[it.possibilities[itIndex].enumRecs[it.possibilities[itIndex].enumRecs.length - 
                                                    i - 1].tag, thisField.allSelections[currentSubMenu].ropes];
                                                    ENDLOOP;
                                                currentSubMenu Ź currentSubMenu + 1;
                                                did Ź TRUE;
                                                EXIT;
                                                };
                                            ENDLOOP;
                                        IF ~ did THEN {
                                            thisField.allSelections[currentSubMenu] Ź [index, LIST["Nil"]];
                                            currentSubMenu Ź currentSubMenu + 1;
                                            };
                                        ENDLOOP;
                                    };
                                ENDCASE => ERROR;
                            }
                        ELSE {
                            thisField.dependentOn Ź NIL;
                            thisField.currentMenu Ź 0;
                            thisField.allSelections Ź NEW[AdobeCommon.SelectionsSequence[1]];
                            thisField.allSelections[0].num Ź it.possibilities[0].enumRecs[0].item;
                            FOR index: CARD IN [0..it.possibilities[0].enumRecs.length) DO
                                thisField.allSelections[0].ropes Ź 
                                CONS[
                                it.possibilities[0].enumRecs[it.possibilities[0].enumRecs.length - index - 1].tag, 
                                thisField.allSelections[0].ropes];
                                ENDLOOP;
                            thisField.currentSelection Ź it.possibilities[0].enumRecs.length - 1;
                            };

                        thisField.button Ź handle.makeButton[
                            parent: thisViewer,
                            x: 0,
                            y: lineIndex * fieldHeight,
                            name: Rope.Concat[it.name, ": "],
                        <<border: FALSE,>>
                            data: handle.fieldViewer.buttons[fieldIndex],
                            scrollable: TRUE,
                            proc: $HintMenuProc,
                            cData: handle.fieldViewer.buttons[fieldIndex]
                            ];
                        [x, y, w, h] Ź handle.getBoxGeometry[thisField.button];
                        thisField.controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 400,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        fieldIndex Ź fieldIndex + 1;
                        };
                    it: AdobeOps.ArFIO => {
                        handle.fieldViewer.buttons[fieldIndex].type Ź arId;
                        handle.fieldViewer.buttons[fieldIndex].button Ź handle.makeButton[
                            parent: thisViewer,
                            x: 0,
                            y: lineIndex * fieldHeight,
                            name: Rope.Concat[it.name, ": "],
                        <<border: FALSE,>>
                            data: handle.fieldViewer.buttons[fieldIndex],
                            scrollable: TRUE,
                            proc: $HintMenuProc,
                            cData: handle.fieldViewer.buttons[fieldIndex]
                            ];
                        [x, y, w, h] Ź handle.getBoxGeometry[handle.fieldViewer.buttons[fieldIndex].button];
                        handle.fieldViewer.buttons[fieldIndex].controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 400,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        handle.setContents[handle.fieldViewer.buttons[fieldIndex].controllerOf, "> 0"];
                        fieldIndex Ź fieldIndex + 1;
                        };
                    it: AdobeOps.DateFIO => {
                        handle.fieldViewer.buttons[fieldIndex].type Ź dateTime;
                        handle.fieldViewer.buttons[fieldIndex].button Ź handle.makeButton[
                            parent: thisViewer,
                            x: 0,
                            y: lineIndex * fieldHeight,
                            name: Rope.Concat[it.name, ": "],
                        <<border: FALSE,>>
                            data: handle.fieldViewer.buttons[fieldIndex],
                            proc: $HintMenuProc,
                            cData: handle.fieldViewer.buttons[fieldIndex]
                            ];
                        [x, y, w, h] Ź handle.getBoxGeometry[handle.fieldViewer.buttons[fieldIndex].button];
                        handle.fieldViewer.buttons[fieldIndex].controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 400,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        fieldIndex Ź fieldIndex + 1;
                        };
                    it: AdobeOps.NumFIO => {
                        handle.fieldViewer.buttons[fieldIndex].type Ź numeric;
                        handle.fieldViewer.buttons[fieldIndex].button Ź handle.makeButton[
                            parent: thisViewer,
                            x: 0,
                            y: lineIndex * fieldHeight,
                            name: Rope.Concat[it.name, ": "],
                        <<border: FALSE,>>
                            data: handle.fieldViewer.buttons[fieldIndex],
                            proc: $HintMenuProc,
                            cData: handle.fieldViewer.buttons[fieldIndex]
                            ];
                        [x, y, w, h] Ź handle.getBoxGeometry[handle.fieldViewer.buttons[fieldIndex].button];
                        handle.fieldViewer.buttons[fieldIndex].controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 400,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        fieldIndex Ź fieldIndex + 1;
                        };
                    it: AdobeOps.FixFIO => {
                        handle.fieldViewer.buttons[fieldIndex].type Ź fixedLengthString;
                        handle.fieldViewer.buttons[fieldIndex].button Ź handle.makeButton[
                            parent: thisViewer,
                            x: 0,
                            y: lineIndex * fieldHeight,
                            name: Rope.Concat[it.name, ": "],
                        <<border: FALSE,>>
                            data: handle.fieldViewer.buttons[fieldIndex],
                            scrollable: FALSE,
                            proc: $HintMenuProc,
                            cData: handle.fieldViewer.buttons[fieldIndex]
                            ];
                        [x, y, w, h] Ź handle.getBoxGeometry[handle.fieldViewer.buttons[fieldIndex].button];
                        handle.fieldViewer.buttons[fieldIndex].controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 20*it.maxLength,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        fieldIndex Ź fieldIndex + 1;
                        };
                    it: AdobeOps.StrFIO => lineIndex Ź lineIndex - 1;
                    ENDCASE;
                lineIndex Ź lineIndex + 1;
                ENDLOOP;
                handle.paintBox[thisViewer, $all];
            };

        QueryCommandProc: PUBLIC PROCEDURE [h: AdobeCommon.Handle] =
            {
        <<windowData: AdobeCommon.DataHandle _ AdobeCommon.GetDataSW[sw];>>
        <<instanceData: AdobeCommonInternal.InstanceDataHandle _>>
        <<windowData.instanceData;>>
            windowData: AdobeCommon.Handle Ź h;
        <<MsgSW.Clear[windowData.msgSW];>>
            IF windowData.system = LAST[CARD] --OR windowData.context = NIL --OR windowData.knownSystems = NIL OR windowData.knownSystems.next 
            = 0 THEN {
                AdobeCommon.PostMessage[
                    windowData, TRUE, "No available systems"];
                RETURN};
            IF windowData.isBusy THEN
                AdobeCommon.PostMessage[windowData, TRUE, 
                "Adobe system is Busy.  Please try again later. "]
            ELSE {
                windowData.isBusy Ź TRUE;
            <<IF instanceData.background THEN>>
            <<Process.Detach[>>
            <<windowData.processID _ FORK AdobeCommon.CatchErrors[>>
            <<sw, item, index, windowData, ChooseQueryCmd]]>>
            <<ELSE {-->>
            <<windowData.processID _ Process.GetCurrent[];>>
                AdobeCommon.CatchErrors[
                    windowData, --item, index, windowData, --ChooseQueryCmd]}--};
            };

        ChooseQueryCmd: PROC[windowData: AdobeCommon.Handle] =
            {
        <<windowData: AdobeUI.Handle _ NARROW[clientData];>>
            { ENABLE UNWIND => windowData.isBusy Ź FALSE;
        <<SELECT index FROM>>
            --queryPos => --QueryProc[windowData];
        <<clearFormPos => ClearQueryForm[windowData];>>
        <<showElemPos => ShowElementsProc[windowData];>>
        <<resetQLPos => ResetQLProc[windowData];>>
        <<ENDCASE => ERROR;>>
            windowData.isBusy Ź FALSE;
        <<windowData.processID _ NIL;>>
            };
            };

        QueryProc: PROCEDURE [data: AdobeCommon.Handle] =
            {
            ql: AdobeOps.QueryList;
            usingSysQL: BOOLEAN;
            qH: ProcessedQueryHandle;
            ok: BOOLEAN;
            instanceData: AdobeCommonInternal.InstanceDataHandle Ź
                NARROW[data.instanceData];
            --AdobeCommonInternal.SetTheDefaults[data, TRUE];
            WITH instanceData SELECT FROM
                queryData: REF AdobeCommonInternal.InstanceData.query => {
                    queryData.qlName Ź data.getContents[data.editors[1]];
                    usingSysQL Ź
                        (queryData.qlName = NIL OR queryData.qlName.Length = 0
                            OR Rope.Equal[queryData.qlName, "SysQL", FALSE]);
                    [ok, qH] Ź ParseQueryGiven[data];
                <<IF UserInput.UserAbort[data.window] THEN ERROR ABORTED;>>
                    IF ok THEN {
                        AdobeCommon.PostMessage[data, FALSE, "Querying into "];
                        AdobeCommon.PostMessage[data, FALSE, 
                            IF usingSysQL THEN "SysQL" ELSE queryData.qlName];
                        AdobeCommon.PostMessage[data, FALSE, " ... "]
                        };
                    IF ~ok THEN RETURN;
                    ql Ź PerformQuery[qH, data ! ParseError => GOTO quit];
                <<IF UserInput.UserAbort[data.window] THEN {ERROR ABORTED};>>
                    IF ql = NIL THEN {
                        ql Ź NEW[AdobeOps.QueryListBody];
                        ql.name Ź NIL; ql.list Ź NIL;
                        AdobeCommon.PostMessage[data, FALSE, "0 matches... "];
                        }
                    ELSE {
                        AdobeCommon.PostNumber[data, FALSE, CountARs[ql.list]];
                        AdobeCommon.PostMessage[data, FALSE, " matches... "]};
                    IF usingSysQL THEN
                        ql.name Ź "SysQL"
                    ELSE
                        ql.name Ź queryData.qlName;
                    IF usingSysQL THEN {data.systemHandle.sysQL Ź ql}
                    ELSE AddToOtherQLList[data.systemHandle, ql];
                    AdobeCommon.PostMessage[data, TRUE, "Done."]
                    };
                ENDCASE => ERROR;  --shouldn't happen
                EXITS quit => NULL;
            };

        ParseQueryGiven: PROCEDURE [data: AdobeCommon.Handle]
            RETURNS [goodParse: BOOLEAN, processedQH: ProcessedQueryHandle] =
            {
            queryCount: CARDINAL Ź 0;
            current: CARD Ź 0;
            instanceData: AdobeCommonInternal.InstanceDataHandle Ź
                NARROW[data.instanceData];
            goodParse Ź TRUE;
            WITH instanceData SELECT FROM
                queryData: REF AdobeCommonInternal.InstanceData.query => {
                <<find out how many items are being queried on >>
                    FOR i: CARDINAL IN [0..queryData.queryStrings.length) DO
                        queryData.queryStrings[i] Ź data.getContents[data.fieldViewer.buttons[i].controllerOf];
                        ENDLOOP;

                    FOR i: CARDINAL IN [0..queryData.queryStrings.length) DO
                        IF ~Rope.IsEmpty[queryData.queryStrings[i]]THEN
                            queryCount Ź queryCount + 1;
                        ENDLOOP;
                    processedQH Ź NEW[ProcessedQuery [queryCount]];
                    queryCount Ź 0;
                    FOR i: CARDINAL IN [0..queryData.queryStrings.length) DO
                        WHILE data.systemHandle.fieldList[current].type = string DO
                            current Ź current + 1;
                            ENDLOOP;
                        IF ~Rope.IsEmpty[queryData.queryStrings[i]] THEN {
                            [goodParse, processedQH[queryCount]] Ź ParseQueryItem[
                                queryData.queryStrings[i], data.systemHandle.fieldList[current]];
                            IF goodParse THEN {
                                processedQH[queryCount].fLIndex Ź current;
                                queryCount Ź queryCount + 1}
                            ELSE {
                                AdobeCommon.PostMessage[data, FALSE, "Query for "];
                                AdobeCommon.PostMessage[data, FALSE, data.systemHandle.fieldList[current].name];
                                AdobeCommon.PostMessage[data, TRUE, " is illegal"];
                            <<FOR i: CARDINAL IN [0..queryCount) DO>>
                            <<data.heap.FREE[@processedQH[i]]; ENDLOOP;>>
                            <<data.heap.FREE[@processedQH];>>
                                EXIT}};
                        current Ź current + 1;
                        ENDLOOP};
                ENDCASE;
            };

        MyGetChar: GetCharProcType = {
            IF h.i < Rope.Length[h.s] THEN {
                c Ź Rope.Fetch[h.s, h.i];
                h.i Ź h.i + 1;
                IF c = '' THEN
                    IF h.i >= Rope.Length[h.s] THEN
                        ERROR ParseError[strayQuote]
                    ELSE {c Ź Rope.Fetch[h.s, h.i]; h.i Ź h.i + 1; e.b Ź TRUE}}
            ELSE c Ź Ascii.NUL};

        BoolRec: TYPE = RECORD[
            b: BOOLEAN Ź FALSE];

        ParseQueryItem: PROCEDURE [
            s: Rope.ROPE, fItem: AdobeOps.FieldItemObject]
            RETURNS [ok: BOOLEAN, queryTokens: QueryItemHandle] =
            {

            collected: Rope.ROPE;
            last, current: ParseStateType;
            tempQueryTokens: QueryItemHandle Ź NEW[QueryItemSeq [10]];
            qtIndex: CARDINAL Ź 0;
            lastWasString: BOOLEAN Ź FALSE;
            escaped: REF BoolRec Ź NEW[BoolRec Ź [FALSE]];

            MyUngetChar: PROCEDURE [h: LSHandle] = {
                h.i Ź h.i - 1};

            DoubleQuote: QuoteProcType = {
                IF c = '" THEN RETURN['"] ELSE RETURN[nonQuote]};

            NonQueryChars: FilterProcType = {
                IF escaped.b THEN {  --char preceded by apostrophe; don't check it
                    escaped.b Ź FALSE;  --reset 
                    RETURN[TRUE]};
                RETURN[
                    SELECT c FROM
                        Ascii.SP, Ascii.TAB, Ascii.CR, '=, '>, '<, '#, '" => FALSE,
                        ENDCASE => TRUE]};

            AnalyzeTokenAndAdd: PROCEDURE = {
                SELECT TRUE FROM
                    Rope.Equal["HAS", collected, FALSE] => {
                        IF lastWasString THEN qtIndex Ź qtIndex + 1;
                        tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [op[in]]];
                        lastWasString Ź FALSE;
                        qtIndex Ź qtIndex + 1};
                    Rope.Equal["~HAS", collected, FALSE] => {
                        IF lastWasString THEN qtIndex Ź qtIndex + 1;
                        tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [op[notIn]]];
                        lastWasString Ź FALSE;
                        qtIndex Ź qtIndex + 1};
                    Rope.Equal["AND", collected, FALSE] => {
                        IF lastWasString THEN qtIndex Ź qtIndex + 1;
                        tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [andor[and]]];
                        lastWasString Ź FALSE;
                        qtIndex Ź qtIndex + 1};
                    Rope.Equal["OR", collected, FALSE] => {
                        IF lastWasString THEN qtIndex Ź qtIndex + 1;
                        tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [andor[or]]];
                        lastWasString Ź FALSE;
                        qtIndex Ź qtIndex + 1};
                    ENDCASE => {
                        IF lastWasString THEN
                            WITH tempQueryTokens[qtIndex] SELECT FROM
                                x: StringDT => {
                                    x.s Ź x.s.Concat[" "];
                                    <<String.AppendCharAndGrow[@s, Ascii.SP, z];>>
                                    x.s Ź x.s.Concat[collected]};
                                    <<String.AppendStringAndGrow[@s, collected, z, 10]};>>
                                ENDCASE
                        ELSE
                            tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [
                                string[--String.CopyToNewString[--collected--, z]--]]];
                        lastWasString Ź TRUE};
                };

            nextChar: CHARACTER Ź Ascii.NUL;
            sH: LSHandle Ź StringToHandle[s];
            sH.object.getChar Ź MyGetChar;
            collected Ź MaybeQuoted[
                h: sH, data: NIL, filter: NonQueryChars, isQuote: DoubleQuote];
            DO
                IF collected # NIL THEN {
                <<compare with tempQueryTokens.len-2 because if collected is a >>
                <<string operator, qtIndex is incremented and then the assignment >>
                <<is done.>>
                    IF qtIndex >= tempQueryTokens.len - 2 THEN
                        tempQueryTokens Ź GrowQueryItemSeq[tempQueryTokens];
                    AnalyzeTokenAndAdd[];
                <<[] _ Token.FreeTokenString[collected]>>
                    }
                ELSE {
                    IF qtIndex >= tempQueryTokens.len THEN
                        tempQueryTokens Ź GrowQueryItemSeq[tempQueryTokens];
                    IF lastWasString THEN qtIndex Ź qtIndex + 1;
                    SELECT sH.object.break FROM
                        '< => {
                            nextChar Ź sH.object.getChar[sH, escaped];
                            IF nextChar = '= THEN 
                                tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [op[lessThanOrEqual]]]
                            ELSE {
                                MyUngetChar[sH];
                                tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [op[lessThan]]]};
                            qtIndex Ź qtIndex + 1};
                        '> => {
                            nextChar Ź sH.object.getChar[sH, escaped];
                            IF nextChar = '= THEN
                                tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [op[greaterThanOrEqual]]]
                            ELSE {
                                MyUngetChar[sH];
                                tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [op[greaterThan]]]};
                            qtIndex Ź qtIndex + 1};
                        '" => MyUngetChar[sH];  --put back so MaybeQuoted finds it
                        '= => {
                            tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [op[equal]]];
                            qtIndex Ź qtIndex + 1};
                        '# => {
                            tempQueryTokens[qtIndex] Ź NEW[DistilledToken Ź [op[notEqual]]];
                            qtIndex Ź qtIndex + 1};
                        Ascii.NUL => {--[] Ź Token.FreeTokenString[collected];-- EXIT};
                    <<all done with this string>>
                        ENDCASE};

            collected Ź MaybeQuoted[
                h: sH, data: NIL, filter: NonQueryChars,
                isQuote: DoubleQuote];
            ENDLOOP;
            ok Ź TRUE;
        <<need to do something special with enumerated items>>
            last Ź start;
            IF qtIndex = 0 THEN ok Ź FALSE;
            FOR i: CARDINAL IN [0..qtIndex) DO
                WITH tempQueryTokens[i] SELECT FROM
                    qt: OpDT => {
                        current Ź op;
                        IF ~ValidOperator[fItem, qt.op] THEN {ok Ź FALSE; EXIT}};
                    qt: StringDT => current Ź string;
                    qt: AndOrDT => current Ź andor;
                    ENDCASE;
                ParseNextToken[
                    last, current, fItem ! ParseError => {ok Ź FALSE; EXIT}];
                last Ź current;
                ENDLOOP;
            ParseNextToken[
                last, end, fItem ! ParseError => {ok Ź FALSE; CONTINUE}];
            IF ok THEN {  --trim to size needed 
                queryTokens Ź NEW[QueryItemSeq [qtIndex]];
                FOR i: CARDINAL IN [0..qtIndex) DO
                    queryTokens[i] Ź tempQueryTokens[i]; ENDLOOP}
            ELSE queryTokens Ź NIL;
            };

        ParseNextToken: PROCEDURE [
            last, this: ParseStateType, item: AdobeOps.FieldItemObject] =
            {
            SELECT last FROM
                start =>
                    SELECT this FROM
                        andor => ERROR ParseError[badQuerySyntax];
                        ENDCASE;
                op =>
                    SELECT this FROM
                        op, andor, end => ERROR ParseError[badQuerySyntax];
                        ENDCASE;
                andor =>
                    SELECT this FROM
                        andor, end => ERROR ParseError[badQuerySyntax];
                        ENDCASE;
                string =>
                    SELECT this FROM
                        op => ERROR ParseError[badQuerySyntax];
                        ENDCASE;
                ENDCASE;
            };

        <<
        Parsing table used:
        last|  this ->
         V                op        andor        string                        end
    <<-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=->>
        start            yes    no            yes(implied = before)    yes
    <<-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=->>
        op                no        no            yes                        no
        -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-==-=-==-=-=-=
        andor            yes    no            yes(implied = before)    no
        -=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
        string            no        yes        yes                        yes
        -=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
        >>

        ValidOperator: PROCEDURE [
            item: REF ANY --AdobeOps.FieldItemObject--, op: AdobeP75V2.Relation]
            RETURNS [valid: BOOLEAN Ź FALSE] =
            {
            WITH item SELECT FROM
                i: AdobeOps.ArFIO => RETURN[AdobeCommon.validRelations[arId][op]];
                i: AdobeOps.DateFIO => RETURN[AdobeCommon.validRelations[dateTime][op]];
                i: AdobeOps.NumFIO => RETURN[AdobeCommon.validRelations[numeric][op]];
                i: AdobeOps.FixFIO =>
                    RETURN[AdobeCommon.validRelations[fixedLengthString][op]];
                i: AdobeOps.EnumFIO =>
                    RETURN[AdobeCommon.validRelations[enumerated][op]];
                i: AdobeOps.StrFIO => NULL;  --not currently allowed
                ENDCASE;
            };

        GrowQueryItemSeq: PROCEDURE [h: QueryItemHandle] 
        RETURNS [newH: QueryItemHandle] =
            {
            newH Ź NEW[QueryItemSeq [h.len + 5]];
            FOR i: CARDINAL IN [0..h.len) DO newH[i] Ź h[i]; ENDLOOP;
            RETURN[newH]
            };

        PerformQuery: PROCEDURE [
            qH: ProcessedQueryHandle, data: AdobeUI.Handle]
            RETURNS [qL: AdobeOps.QueryList] =
            {
            ENABLE {
                AdobeP75V2.CourierTimedOut => AdobeCommon.PostMessage[data, TRUE, "CTO"];
                AdobeP75V2.TooManyConnections => AdobeCommon.PostMessage[data, TRUE, "TMC"];
                AdobeP75V2.SystemAlreadyExists => AdobeCommon.PostMessage[data, TRUE, "SAE"];
                AdobeP75V2.IllegalLogin => AdobeCommon.PostMessage[data, TRUE, "IL"];
                AdobeP75V2.Xxx => AdobeCommon.PostMessage[data, TRUE, "xxx"];
                AdobeP75V2.Error => AdobeCommon.PostMessage[data, TRUE, "Err"];
                AdobeP75V2.ServerDown => AdobeCommon.PostMessage[data, TRUE, "SD"];
                AdobeP75V2.ServerUnreachable => AdobeCommon.PostMessage[data, TRUE, "SU"];
                AdobeP75V2.ParameterInconsistency => AdobeCommon.PostMessage[data, TRUE, "PI"];
                AdobeP75V2.SystemNotRegistered => AdobeCommon.PostMessage[data, TRUE, "SNR"];
                AdobeP75V2.FileNotFound => AdobeCommon.PostMessage[data, TRUE, "FNF"];
                AdobeP75V2.NoAdobeServiceAtServer => AdobeCommon.PostMessage[data, TRUE, "NASAS"];
                AdobeP75V2.CommunicationError => AdobeCommon.PostMessage[data, TRUE, "CE"];
                AdobeP75V2.Spare1 => AdobeCommon.PostMessage[data, TRUE, "S1"];
                AdobeP75V2.Spare2 => AdobeCommon.PostMessage[data, TRUE, "S2"];
                AdobeP75V2.SysDescChanging => AdobeCommon.PostMessage[data, TRUE, "SDC"];
                AdobeP75V2.UnknownSystem => AdobeCommon.PostMessage[data, TRUE, "US"];
                AdobeP75V2.ObsoleteVersion => AdobeCommon.PostMessage[data, TRUE, "OV"];
                AdobeP75V2.CantDetermineLocOfARs => AdobeCommon.PostMessage[data, TRUE, "CDLOR"];
                AdobeP75V2.Others => AdobeCommon.PostMessage[data, TRUE, "Oth"];
                };
            local: Rope.ROPE Ź NIL;
            qHIndex: CARDINAL Ź 0;
            queryItem: QueryItemHandle;
            queryValue: FieldItemHandle;
            numberOfEnum, itemIndex: CARDINAL;
            boolOp: {and, or, new};
            fieldSet, set: AdobeOps.SetOfARs Ź NIL;
            { ENABLE UNWIND =>  {IF qL # NIL THEN {
                qL Ź NIL};
                <<AdobeOps.z.FREE[@qL.list];>>
                <<AdobeOps.z.FREE[@qL]};>>
                IF queryValue # NIL THEN queryValue Ź NIL};
                <<AdobeOps.z.FREE[@queryValue]};>>
            qL Ź NEW[AdobeOps.QueryListBody Ź [NIL, NIL]];
            qL.list Ź NEW[AdobeOps.SetOfARsObject[1]];
            queryValue Ź NEW[FieldItemSeq[3]];
            local Ź AccessCH.NSNameFromRope[data.knownSystems.system[data.system]].local;
            qL.list[0] Ź [
                startValue: 1,
                runLength: XNSAdobeClientOps.ReadLastARNumber[
                server: data.systemHandle.service,
                system: local]];  --initial
            FOR qHIndex IN [0..qH.len) DO
                queryItem Ź qH[qHIndex];
                itemIndex Ź 0;
                boolOp Ź new;
                DO  --make queries for this field
                <<IF UserInput.UserAbort[data.window] THEN {>>
                <<qL _ NIL; ERROR ABORTED}; --leaks!>>
                    WITH queryItem[itemIndex] SELECT FROM
                        x: OpDT => {
                            queryValue[0].relationalOp Ź x.op;
                            itemIndex Ź itemIndex + 1};
                        x: StringDT => queryValue[0].relationalOp Ź equal;
                        ENDCASE;
                    numberOfEnum Ź 0;
                    WITH queryItem[itemIndex] SELECT FROM
                        x: StringDT =>
                            numberOfEnum Ź MakeFieldItemValue[
                                x.s, data.systemHandle.fieldList[queryItem.fLIndex], queryValue ! 
                                ParseError => SELECT errType FROM
                                    badNumber => {
                                        AdobeCommon.PostMessage[data, FALSE, "Invalid Number in "];
                                        AdobeCommon.PostMessage[data, TRUE,  data.systemHandle.fieldList[queryItem.fLIndex].name]};
                                    badDate => {
                                        AdobeCommon.PostMessage[data, FALSE, "Invalid Date in "];
                                        AdobeCommon.PostMessage[data, TRUE,  data.systemHandle.fieldList[queryItem.fLIndex].name]};
                                    ENDCASE => {
                                        AdobeCommon.PostMessage[data, FALSE, "Unknown problem with "];
                                        AdobeCommon.PostMessage[data, TRUE, data.systemHandle.fieldList[queryItem.fLIndex].name]}];
                        ENDCASE;
                    itemIndex Ź itemIndex + 1;
                    IF numberOfEnum > 0 THEN set Ź GetEnumeratedSet[data, qL.list, queryItem.fLIndex, numberOfEnum, queryValue]
                    ELSE 
                    set Ź XNSAdobeClientOps.LookupARs[
                        data.systemHandle.service, AccessCH.NSNameFromRope[data.knownSystems.system[data.system]].local,
                        data.systemHandle.version,
                        data.systemHandle.fieldList[queryItem.fLIndex].name,
                        queryValue[0], qL.list];
                    SELECT boolOp FROM
                        new => fieldSet Ź set;
                        and => fieldSet Ź AndSets[fieldSet, set];
                        or => fieldSet Ź OrSets[fieldSet, set];
                        ENDCASE;
                    IF itemIndex = queryItem.len THEN EXIT;
                    WITH queryItem[itemIndex] SELECT FROM
                        qi: AndOrDT =>
                            boolOp Ź SELECT qi.andOr FROM and => and, ENDCASE => or;  --has to be if not and
                        ENDCASE;
                    itemIndex Ź itemIndex + 1;
                    ENDLOOP;
            <<for now, we're using implicit AND's between fields. Need different scheme if we allow choice of AND/OR between fields.>>
                qL.list Ź AndSets[qL.list, fieldSet];
                IF qL.list = NIL THEN  --no AR's fit criteria
                    RETURN[NIL];
                ENDLOOP;
            };
            };

        GetEnumeratedSet: PROCEDURE[data: AdobeUI.Handle, list: AdobeOps.SetOfARs, flIndex, numberOfEnum: CARDINAL, fieldItem: 
        FieldItemHandle] RETURNS [fieldSet: AdobeOps.SetOfARs] =
            {
            local: Rope.ROPE Ź AccessCH.NSNameFromRope[data.knownSystems.system[data.system]].local;
            set: AdobeOps.SetOfARs Ź NIL;
            FOR i: CARDINAL IN [0..numberOfEnum) DO
                set Ź XNSAdobeClientOps.LookupARs[
                    data.systemHandle.service, local,
                    data.systemHandle.version,
                    data.systemHandle.fieldList[flIndex].name,
                    fieldItem[i], list];
                IF i = 0 THEN fieldSet Ź set
                ELSE {
                    IF fieldItem[0].relationalOp = equal THEN
                        fieldSet Ź OrSets[fieldSet, set]
                    ELSE IF fieldItem[0].relationalOp = notEqual THEN
                        fieldSet Ź AndSets[fieldSet, set]};
                ENDLOOP;
            };

        MakeFieldItemValue: PROCEDURE [
            s: Rope.ROPE, fLItem: AdobeOps.FieldItemObject, f: FieldItemHandle]
            RETURNS [numberOfEnum: CARDINAL Ź 0] =
            {
            ENABLE Convert.Error => {};  --do something here
        <<want to add code to recognize special strings>>
            fIndex: CARDINAL Ź 0;
            IF Rope.Equal[s, "NIL", FALSE] THEN  --want empties
                WITH fLItem SELECT FROM
                    x: AdobeOps.ArFIO => f[fIndex].value Ź NEW [AdobeServer.FieldItemValueRec Ź [arId[AdobeOps.nilARNumber]]];
                    x: AdobeOps.DateFIO => f[fIndex].value Ź NEW [AdobeServer.FieldItemValueRec Ź [dateTime[LOOPHOLE[LONG[0], BasicTime.GMT]]]];
                    x: AdobeOps.NumFIO => f[fIndex].value Ź NEW [AdobeServer.FieldItemValueRec Ź [numeric[LONG[0]]]];
                    x: AdobeOps.FixFIO => f[fIndex].value Ź NEW [AdobeServer.FieldItemValueRec Ź [fixedLengthString[NIL, x.maxLength]]];
                    x: AdobeOps.EnumFIO => f[fIndex].value Ź NEW [AdobeServer.FieldItemValueRec Ź [enumerated[AdobeOps.nilEnum]]];
                    ENDCASE
            ELSE
                WITH fLItem SELECT FROM
                    x: AdobeOps.ArFIO => f[fIndex].value Ź NEW[AdobeServer.FieldItemValueRec Ź [arId[Convert.CardFromRope[s ! Convert.Error => 
                    ParseError[badNumber]]]]];
                    x: AdobeOps.DateFIO => f[fIndex].value Ź NEW[AdobeServer.FieldItemValueRec Ź [dateTime[ConvertDate[s]]]];
                    x: AdobeOps.NumFIO =>
                        f[fIndex].value Ź NEW[AdobeServer.FieldItemValueRec Ź [numeric[Convert.CardFromRope[s !
                            Convert.Error => ParseError[badNumber]]]]];
                    x: AdobeOps.FixFIO => f[fIndex].value Ź NEW[AdobeServer.FieldItemValueRec Ź [fixedLengthString[s, x.maxLength]]];
                    x: AdobeOps.EnumFIO =>
                        numberOfEnum Ź ObtainEnumeratedValue[s, fLItem, NEW[FieldItemHandle Ź f]];
                    ENDCASE;

            };

        ConvertDate: PROCEDURE [s: Rope.ROPE]
            RETURNS [dt: BasicTime.GMT] =
            {
            ENABLE
                Convert.Error => {
                    temp: Rope.ROPE Ź NIL;
                    temp Ź temp.Concat[s];
                    temp Ź temp.Concat[" 00:00:00"];
                    dt Ź Convert.TimeFromRope[
                        temp !
                        Convert.Error => {GOTO badDate}];
                    GOTO ok};
            dt Ź Convert.TimeFromRope[s];
            EXITS badDate => ERROR ParseError[badDate]; ok => NULL;  --return dt
            };

        ObtainEnumeratedValue: PROCEDURE [
            s: Rope.ROPE, item: AdobeOps.FieldItemObject, fieldSeq: REF FieldItemHandle]
            RETURNS [numberOfEnum: CARDINAL Ź 0] =
            {
            temp, tempFieldSeq: FieldItemHandle;
            WITH item SELECT FROM
                it: AdobeOps.EnumFIO => {
                    FOR i: CARDINAL IN [0..it.possibilities.length) DO
                        FOR j: CARDINAL IN [0..it.possibilities[i].enumRecs.length) DO
                            IF Rope.Equal[s, it.possibilities[i].enumRecs[j].tag]
                                THEN {
                                <<if necessary, grow fieldSeq by 10>>
                                    IF numberOfEnum >= fieldSeq.len THEN {
                                        tempFieldSeq Ź NEW[FieldItemSeq[fieldSeq.len + 10]];
                                        FOR k: CARDINAL IN [0..numberOfEnum) DO
                                            tempFieldSeq[k].value Ź fieldSeq[k].value;
                                            tempFieldSeq[k].relationalOp Ź fieldSeq[k].relationalOp;
                                            ENDLOOP;
                                        temp Ź fieldSeq­;
                                        fieldSeq­ Ź tempFieldSeq};
                                    fieldSeq[numberOfEnum].value Ź 
                                        NEW[AdobeServer.FieldItemValueRec Ź [enumerated[it.possibilities[i].enumRecs[j].item]]];
                                    fieldSeq[numberOfEnum].relationalOp Ź fieldSeq[0].relationalOp;
                                    numberOfEnum Ź numberOfEnum + 1};
                            ENDLOOP;
                        ENDLOOP;
                    IF numberOfEnum = 0 THEN ERROR ParseError[notValidEnumerated]};
                ENDCASE;
            };

        AndSets: PUBLIC PROCEDURE [set1, set2: AdobeOps.SetOfARs]
            RETURNS [resultSet: AdobeOps.SetOfARs] =
            {
        <<assume that ARs given are in numeric order>>
            ar1, ar2: AdobeOps.ARNumber;
            set1Status, set2Status: AdobeCommon.SetStatus Ź
                AdobeCommon.InitialSetStatus;
            resultState: CARDINAL Ź 0;
            tempSet: AdobeOps.SetOfARs;
            IF set1 = NIL THEN RETURN[NIL]
            ELSE IF set2 = NIL THEN RETURN[NIL];
            tempSet Ź NEW[AdobeOps.SetOfARsObject[MAX[set1.len, set2.len]]];
            [ar1, set1Status] Ź AdobeCommon.GetNextAR[set1, set1Status];
            [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
        <<initialize temp>>
            FOR i: CARDINAL IN [0..tempSet.len) DO
                tempSet[i] Ź [0, 0]; ENDLOOP;
        <<For AND, when one set is exhausted, we've got all that are>>
        <<common to both so can just exit knowing we're done>>
            WHILE set1Status.setIndex < set1.len
                AND set2Status.setIndex < set2.len DO
                SELECT TRUE FROM
                    ar1 = ar2 => {
                        resultState Ź 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 RETURN[NIL];
        <<prune to just fit>>
            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};
            };

        OrSets: PUBLIC PROCEDURE [set1, set2: AdobeOps.SetOfARs]
            RETURNS [resultSet: AdobeOps.SetOfARs] =
            {
        <<assume that ARs given are in numeric order>>
            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;
        <<initialize temp>>
            FOR i: CARDINAL IN [0..tempSet.len) DO
                tempSet[i] Ź [0, 0]; ENDLOOP;
        <<For OR, when one set is exhausted, we've got to append what >>
        <<remains of the unexhausted set to the result.>>
            WHILE set1Status.setIndex < set1.len
                AND set2Status.setIndex < set2.len DO
                SELECT TRUE FROM
                    ar1 = ar2 => {  --add only once
                        resultState Ź AddToSet[ar1, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                        [ar2, set2Status] Ź AdobeCommon.GetNextAR[set2, set2Status];
                        [ar1, set1Status] Ź AdobeCommon.GetNextAR[
                            set1, set1Status]};
                    ar1 > ar2 => {
                        resultState Ź AddToSet[ar2, NEW[AdobeOps.SetOfARs Ź tempSet], resultState];
                        [ar2, set2Status] Ź AdobeCommon.GetNextAR[
                            set2, set2Status]};
                    ar1 < ar2 => {
                        resultState Ź 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 Ź 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 Ź 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};
            };

        AddToSet: PUBLIC PROCEDURE [
            arNum: AdobeOps.ARNumber, set: REF AdobeOps.SetOfARs,
            lastRef: CARDINAL] RETURNS [thisRef: CARDINAL] =
            {
            thisRef Ź lastRef;
            IF set[lastRef].startValue = 0 THEN set[lastRef] Ź [arNum, 1]
            ELSE
                IF (set[lastRef].startValue + set[lastRef].runLength) = arNum
                    THEN set[lastRef].runLength Ź set[lastRef].runLength + 1
                ELSE {
                    thisRef Ź thisRef + 1;
                    IF thisRef >= set.len THEN GrowSet[set];
                    set[thisRef].startValue Ź arNum;
                    set[thisRef].runLength Ź 1};
            };

        GrowSet: PUBLIC PROCEDURE [
            oldSet: REF AdobeOps.SetOfARs] =
            {
            newSet: REF AdobeOps.SetOfARs Ź 
            NEW[AdobeOps.SetOfARs Ź 
            NEW[AdobeOps.SetOfARsObject[oldSet.len + 50]]];
            FOR i: CARDINAL IN [0..oldSet.len) DO
                newSet[i] Ź oldSet[i]; ENDLOOP;
            oldSet­ Ź newSet­;
            };

        AddToOtherQLList: PUBLIC PROCEDURE [
            arSH: AdobeOps.ARSystemHandle, ql: AdobeOps.QueryList] =
            {
            qlIndex: AdobeOps.QLHandle Ź arSH.otherQLs;
            DO
                SELECT TRUE FROM
                    qlIndex = NIL => {
                        arSH.otherQLs Ź NEW[AdobeOps.QLObject Ź [ql, NIL]];
                        EXIT};
                    Rope.Equal[qlIndex.qL.name, ql.name] => {qlIndex.qL Ź ql; EXIT};
                    qlIndex.next = NIL => {
                        qlIndex.next Ź NEW[AdobeOps.QLObject Ź [ql, NIL]];
                        EXIT;}
                    ENDCASE;
                qlIndex Ź qlIndex.next;
                ENDLOOP;
            };

        }. . .

    17-Jul-87 13:54:56 - rlc - Use String.StringToLongNumber rather than LONG[String.StringToNumber]. Good Grief CB!