<<>>
<<MessageTabImpl.mesa>>
    <<Copyright Ó 1988, 1989, 1991 by Xerox Corporation.  All rights reserved.>>
    <<created by Satterthwaite, April 9, 1986 11:06:50 am PST>>
    <<Russ Atkinson (RRA) May 23, 1989 8:15:24 pm PDT>>

    DIRECTORY
        ConvertUnsafe USING [ToRope],
        MessageTab USING [],
        MimosaLog USING [ErrorCode],
        Rope USING [ROPE],
        Symbols USING [TransferMode, TypeClass],
        Tree USING [NodeName];
MessageTabImpl: PROGRAM
    IMPORTS ConvertUnsafe
    EXPORTS MessageTab = {

    ROPE: TYPE = Rope.ROPE;

    NodePrintName: PUBLIC PROC [name: Tree.NodeName] RETURNS [ROPE] = {
        str: STRING Ź NIL;
        SELECT name FROM
            list => str Ź "list";
            item => str Ź "item";
            decl => str Ź "decl";
            typedecl => str Ź "typedecl";
            basicTC => str Ź "basicTC";
            enumeratedTC => str Ź "enumeratedTC";
            recordTC => str Ź "recordTC";
            monitoredTC => str Ź "monitoredTC";
            variantTC => str Ź "variantTC";
            refTC => str Ź "refTC";
            pointerTC => str Ź "pointerTC";
            listTC => str Ź "listTC";
            arrayTC => str Ź "arrayTC";
            arraydescTC => str Ź "arraydescTC";
            sequenceTC => str Ź "sequenceTC";
            procTC => str Ź "procTC";
            processTC => str Ź "processTC";
            portTC => str Ź "portTC";
            signalTC => str Ź "signalTC";
            errorTC => str Ź "errorTC";
            programTC => str Ź "programTC";
            anyTC => str Ź "anyTC";
            definitionTC => str Ź "definitionTC";
            unionTC => str Ź "unionTC";
            relativeTC => str Ź "relativeTC";
            subrangeTC => str Ź "subrangeTC";
            longTC => str Ź "longTC";
            opaqueTC => str Ź "opaqueTC";
            zoneTC => str Ź "zoneTC";
            linkTC => str Ź "linkTC";
            varTC => str Ź "varTC";
            implicitTC => str Ź "implicitTC";
            frameTC => str Ź "frameTC";
            discrimTC => str Ź "discrimTC";
            paintTC => str Ź "paintTC";
            optionTC => str Ź "optionTC";
            spareTC => str Ź "spareTC?";
            unit => str Ź "unit";
            diritem => str Ź "diritem";
            module => str Ź "module";
            body => str Ź "body";
            inline => str Ź "inline";
            lambda => str Ź "lambda";
            block => str Ź "block";
            assign => str Ź "assign";
            extract => str Ź "extract";
            if => str Ź "if";
            case => str Ź "case";
            casetest => str Ź "casetest";
            caseswitch => str Ź "caseswitch";
            bind => str Ź "bind";
            do => str Ź "do";
            forseq => str Ź "forseq";
            upthru => str Ź "upthru";
            downthru => str Ź "downthru";
            return => str Ź "return";
            result => str Ź "result";
            goto => str Ź "goto";
            exit => str Ź "exit";
            loop => str Ź "loop";
            free => str Ź "free";
            resume => str Ź "resume";
            reject => str Ź "reject";
            continue => str Ź "continue";
            retry => str Ź "retry";
            catchmark => str Ź "catchmark";
            restart => str Ź "restart";
            stop => str Ź "stop";
            lock => str Ź "lock";
            wait => str Ź "wait";
            notify => str Ź "notify";
            broadcast => str Ź "broadcast";
            unlock => str Ź "unlock";
            null => str Ź "null";
            label => str Ź "label";
            open => str Ź "open";
            enable => str Ź "enable";
            catch => str Ź "catch";
            dst => str Ź "dst";
            lste => str Ź "lste";
            lstf => str Ź "lstf";
            syscall => str Ź "syscall";
            checked => str Ź "checked";
            lst => str Ź "lst";
            spareS3 => str Ź "spareS3";
            subst => str Ź "subst";
            call => str Ź "call";
            portcall => str Ź "portcall";
            signal => str Ź "signal";
            error => str Ź "error";
            syserror => str Ź "syserror";
            xerror => str Ź "xerror";
            start => str Ź "start";
            join => str Ź "join";
            apply => str Ź "apply";
            callx => str Ź "callx";
            portcallx => str Ź "portcallx";
            signalx => str Ź "signalx";
            errorx => str Ź "errorx";
            syserrorx => str Ź "syserrorx";
            startx => str Ź "startx";
            fork => str Ź "fork";
            joinx => str Ź "joinx";
            index => str Ź "index";
            dindex => str Ź "dindex";
            seqindex => str Ź "seqindex";
            reloc => str Ź "reloc";
            construct => str Ź "construct";
            union => str Ź "union";
            rowcons => str Ź "rowcons";
            sequence => str Ź "sequence";
            listcons => str Ź "listcons";
            substx => str Ź "substx";
            ifx => str Ź "ifx";
            casex => str Ź "casex";
            bindx => str Ź "bindx";
            assignx => str Ź "assignx";
            extractx => str Ź "extractx";
            or => str Ź "or";
            and => str Ź "and";
            relE => str Ź "relE";
            relN => str Ź "relN";
            relL => str Ź "relL";
            relGE => str Ź "relGE";
            relG => str Ź "relG";
            relLE => str Ź "relLE";
            in => str Ź "in";
            notin => str Ź "notin";
            plus => str Ź "plus";
            minus => str Ź "minus";
            times => str Ź "times";
            div => str Ź "div";
            mod => str Ź "mod";
            power => str Ź "power";
            dot => str Ź "dot";
            cdot => str Ź "cdot";
            dollar => str Ź "dollar";
            create => str Ź "create";
            not => str Ź "not";
            uminus => str Ź "uminus";
            addr => str Ź "addr";
            uparrow => str Ź "uparrow";
            min => str Ź "min";
            max => str Ź "max";
            ord => str Ź "ord";
            val => str Ź "val";
            abs => str Ź "abs";
            all => str Ź "all";
            size => str Ź "size";
            first => str Ź "first";
            last => str Ź "last";
            pred => str Ź "pred";
            succ => str Ź "succ";
            arraydesc => str Ź "arraydesc";
            length => str Ź "length";
            base => str Ź "base";
            loophole => str Ź "loophole";
            nil => str Ź "nil";
            new => str Ź "new";
            void => str Ź "void";
            clit => str Ź "clit";
            llit => str Ź "llit";
            cast => str Ź "cast";
            check => str Ź "check";
            float => str Ź "float";
            pad => str Ź "pad";
            chop => str Ź "chop";
            safen => str Ź "safen";
            syscallx => str Ź "syscallx";
            narrow => str Ź "narrow";
            istype => str Ź "istype";
            openx => str Ź "openx";
            mwconst => str Ź "mwconst";
            cons => str Ź "cons";
            atom => str Ź "atom";
            typecode => str Ź "typecode";
            stringinit => str Ź "stringinit";
            textlit => str Ź "textlit";
            signalinit => str Ź "signalinit";
            procinit => str Ź "procinit";
            intOO => str Ź "intOO";
            intOC => str Ź "intOC";
            intCO => str Ź "intCO";
            intCC => str Ź "intCC";
            thread => str Ź "thread";
            none => str Ź "none";
            exlist => str Ź "exlist";
            initlist => str Ź "initlist";
            ditem => str Ź "ditem";
            lengthen => str Ź "lengthen";
            shorten => str Ź "shorten";
            self => str Ź "self";
            gcrt => str Ź "gcrt";
            proccheck => str Ź "proccheck";
            entry => str Ź "entry";
            internal => str Ź "internal";
            invalid => str Ź "INVALID";
            ENDCASE;
        RETURN [ConvertUnsafe.ToRope[str]];
        };

    TypePrintName: PUBLIC PROC [class: Symbols.TypeClass] RETURNS [ROPE] = {
        str: STRING Ź NIL;
        SELECT class FROM
            mode => str Ź "mode";
            basic => str Ź "basic";
            signed => str Ź "signed";
            unsigned => str Ź "unsigned";
            real => str Ź "real";
            enumerated => str Ź "enumerated";
            record => str Ź "record";
            ref => str Ź "ref";
            array => str Ź "array";
            arraydesc => str Ź "arraydesc";
            transfer => str Ź "transfer";
            definition => str Ź "definition";
            union => str Ź "union";
            sequence => str Ź "sequence";
            relative => str Ź "relative";
            subrange => str Ź "subrange";
            opaque => str Ź "opaque";
            zone => str Ź "zone";
            any => str Ź "any";
            nil => str Ź "NIL";
            ENDCASE;
        RETURN [ConvertUnsafe.ToRope[str]];
        };

    ModePrintName: PUBLIC PROC [mode: Symbols.TransferMode] RETURNS [ROPE] = {
        str: STRING Ź NIL;
        SELECT mode FROM
            proc => str Ź "proc";
            port => str Ź "port";
            signal => str Ź "signal";
            error => str Ź "error";
            process => str Ź "process";
            program => str Ź "program";
            other => str Ź "other";
            none => str Ź "none";
            ENDCASE;
        RETURN [ConvertUnsafe.ToRope[str]];
        };

    OpName: PUBLIC PROC [name: Tree.NodeName[$assignx..$uparrow]] RETURNS [ROPE] = {
        str: STRING Ź NIL;
        SELECT name FROM
            assignx => str Ź "_";
            extractx => str Ź "_";
            or => str Ź " OR ";
            and => str Ź " AND ";
            relE => str Ź "=";
            relN => str Ź "#";
            relL => str Ź "<";
            relGE => str Ź ">=";
            relG => str Ź ">";
            relLE => str Ź "<=";
            in => str Ź " IN ";
            notin => str Ź " NOT IN ";
            plus => str Ź "+";
            minus => str Ź "-";
            times => str Ź "*";
            div => str Ź "/";
            mod => str Ź " MOD ";
            power => str Ź " ** ";
            dot => str Ź ".";
            cdot => str Ź ".";
            dollar => str Ź ".";
            create => str Ź " NEW ";
            not => str Ź " NOT ";
            uminus => str Ź "-";
            addr => str Ź "@";
            uparrow => str Ź "^";
            ENDCASE;
        RETURN [ConvertUnsafe.ToRope[str]];
        };

    FnName: PUBLIC PROC [name: Tree.NodeName[$min..$new]] RETURNS [ROPE] = {
        str: STRING Ź NIL;
        SELECT name FROM
            min => str Ź "MIN";
            max => str Ź "MAX";
            ord => str Ź "ORD";
            val => str Ź "VAL";
            abs => str Ź "ABS";
            all => str Ź "ALL";
            size => str Ź "SIZE";
            first => str Ź "FIRST";
            last => str Ź "LAST";
            pred => str Ź "PRED";
            succ => str Ź "SUCC";
            arraydesc => str Ź "DESCRIPTOR";
            length => str Ź "LENGTH";
            base => str Ź "BASE";
            loophole => str Ź "LOOPHOLE";
            nil => str Ź "NIL";
            new => str Ź "NEW";
            ENDCASE;
        RETURN [ConvertUnsafe.ToRope[str]];
        };

    ApplName: PUBLIC PROC [name: Tree.NodeName[$apply..$joinx]] RETURNS [ROPE] = {
        str: STRING Ź NIL;
        SELECT name FROM
            apply => str Ź "APPLY";
            callx => str Ź "APPLY";
            portcallx => str Ź "";
            signalx => str Ź "SIGNAL";
            errorx => str Ź "ERROR";
            syserrorx => str Ź "ERROR";
            startx => str Ź "START";
            fork => str Ź "FORK";
            joinx => str Ź "JOIN";
            ENDCASE;
        RETURN [ConvertUnsafe.ToRope[str]];
        };

    FApplName: PUBLIC PROC [name: Tree.NodeName[$restart..$broadcast]] RETURNS [ROPE] = {
        str: STRING Ź NIL;
        SELECT name FROM
            restart => str Ź "RESTART";
            stop => str Ź "STOP";
            lock => str Ź "LOCK";
            wait => str Ź "WAIT";
            notify => str Ź "NOTIFY";
            broadcast => str Ź "BROADCAST";
            ENDCASE;
        RETURN [ConvertUnsafe.ToRope[str]];
        };

    ErrorMessages: PUBLIC PROC [code: MimosaLog.ErrorCode] RETURNS [ROPE] = {
        str: STRING Ź NIL;
        SELECT code FROM
            <<>>
            <<general purpose errors (no parameters)>>

            compilerError => str Ź "FATAL COMPILER ERROR";
            unimplemented => str Ź "unimplemented construct";
            other => str Ź "unspecified error";
            aborted => str Ź "compilation aborted";

            <<errors with no parameters>>

            arraySize => str Ź "array too large for implementation";
            attrClash => str Ź "invalid attribute combination";
            bodyType => str Ź "illegal initialization to body";
            catchLabel => str Ź "misplaced RETRY or CONTINUE";
            descriptor => str Ź "misused DESCRIPTOR";
            discrimForm => str Ź "incorrect discrimination";
            exit => str Ź "misplaced EXIT or LOOP";
            illDefinedReturn => str Ź "default return of anonymous value";
            implicitCall => str Ź "implicit system call";
            indexType => str Ź "illegal index type";
            inlineChecked => str Ź "MACHINE CODE cannot be CHECKED";
            inlineType => str Ź "illegal initialization to MACHINE CODE";
            instLength => str Ź "instruction has incorrect length";
            interfaceString => str Ź "string literals not permitted in DEFINITIONS";
            keys => str Ź "keywords not permitted";
            long => str Ź "misused LONG";
            longPath => str Ź "must be in MDS";
            machDep => str Ź "type must be MACHINE DEPENDENT";
            misplacedCatch => str Ź "misplaced catch phrase";
            misplacedEntry => str Ź "unmonitored ENTRY or INTERNAL";
            misplacedMonitorRef => str Ź "unmonitored WAIT or NOTIFY";
            misplacedResume => str Ź "misplaced REJECT or RESUME";
            misplacedReturn => str Ź "misplaced RETURN";
            misplacedStop => str Ź "misplaced STOP";
            misplacedType => str Ź "misplaced opaque type declaration";
            mixedPositions => str Ź "mixed explicit and implicit field positions";
            noAccess => str Ź "attempt to access private fields";
            nonOrderedType => str Ź "index or interval type must be ordered";
            nonTypeCons => str Ź "unrecognizable type constructor";
            nonVoidStmt => str Ź "procedure used as a statement returns a value";
            opaqueTest => str Ź "discrimination on opaque types is unimplemented";
            relative => str Ź "misused RELATIVE";
            stateVector => str Ź "state vector has improper offset";
            staticNesting => str Ź "body or catch phrase nested too deeply";
            subrangeNesting => str Ź "interval bounds are out of range";
            unsafeBlock => str Ź "improper use of an unsafe block";
            var => str Ź "misused VAR";
            <<>>
            <<errors mapping hash to sei parameters>>

            unknownId => str Ź "is undeclared";
            unknownField => str Ź "is not valid as a field selector";
            <<>>
            <<errors with hash parameters>>

            ambiguousId => str Ź "is ambiguous without discrimination";
            duplicateId => str Ź "is multiply defined";
            missingImport => str Ź "is an unmatched implicit import";
            unknownTag => str Ź "is not a legal variant tag";
            duplicateTag => str Ź "labels multiple variants";
            unknownVariant => str Ź "does not name a variant";
            unknownKey => str Ź "is not valid as a key";
            duplicateKey => str Ź "is repeated as a key";
            omittedKey => str Ź "cannot be defaulted";
            openId => str Ź "must label a record";
            fileName => str Ź "cannot be opened";
            fileWrong => str Ź "found in wrong version";
            moduleId => str Ź "is not a module name";
            <<>>
            <<errors with sei parameters>>

            addressOverflow => str Ź "exceeds addressing limits";
            circularType => str Ź "leads to a circular type definition"; 
            circularValue => str Ź "has ill-defined or circular value";
            elision => str Ź "cannot be defaulted or voided";
            enumOrder => str Ź "is out of order";
            exportAttr => str Ź "is exported with incorrect attributes";
            exportClash => str Ź "is exported with incorrect type";
            fieldPosition => str Ź "has invalid field width or alignment";
            forwardRef => str Ź "is used before set";
            internalCall => str Ź "is a misused INTERNAL";
            missingBase => str Ź "requires a base value";
            missingInit => str Ź "requires an initial value";
            missingLock => str Ź "required for lock";
            nonDefinition => str Ź "improperly defined for a DEFINITIONS module";
            nonTagType => str Ź "has a type illegal for a tag";
            nonTypeId => str Ź "is not a type";
            notImported => str Ź "must come from an imported interface";
            position => str Ź "cannot have a specified position";
            privateId => str Ź "is private";
            recordGap => str Ź "is followed by a gap";
            recordOverlap => str Ź "overlaps another field";
            recursiveInline => str Ź "is INLINE and recursive";
            typeLength => str Ź "has unknown or ill-defined size";
            updateClash => str Ź "must be exported as READONLY";
            varExport => str Ź "has no exportable value";

            <<errors with tree parameters>>

            boundsFault => str Ź "is out of range";
            controlId => str Ź "is an improper control variable";
            defaultForm => str Ź "has an invalid default";
            duplicateLabel => str Ź "is multiply defined";
            missingBinding => str Ź "lacks a tag needed for discrimination";
            misusedInline => str Ź "is an incorrectly used inline";
            mixedRepresentation => str Ź "has signed/unsigned ambiguity";
            noApplication => str Ź "does not allow an argument list";
            nonAddressable => str Ź "does not allow indirect reference";
            nonConstant => str Ź "has nonconstant value";
            nonInterface => str Ź "must have an interface type";
            nonLHS => str Ź "is not a variable";
            nonVar => str Ź "is not address (@) of a variable";
            nonVariantLabel => str Ź "specifies an inadmissable test";
            noTarget => str Ź "requires explicit type";
            notImExPortable => str Ź "is not importable/exportable";
            noVariants => str Ź "has no variants";
            overflow => str Ź "overflows";
            operandSize => str Ź "has a size exceeding implementation limits";
            scopeFault => str Ź "is being assigned out of scope";
            sizeClash => str Ź "has incorrect or ambiguous length";
            spuriousBinding => str Ź "explicit selection not permitted";
            typeClash => str Ź "has incorrect type";
            unknownLabel => str Ź "is undeclared";
            unsafeOperation => str Ź "uses an unsafe operation";
            unsafeSelection => str Ź "is discriminated unsafely";

            <<errors with tree and operator parameters>>

            missingAttr => str Ź "has no ";
            missingOp => str Ź "has a type with no ";
            unsafeOp => str Ź "uses an unsafe ";
            <<>>
            <<errors with numeric parameters>>

            bodyEntries => str Ź "too many procedure or signal definitions";
            exportedVars => str Ź "too many exported variables";
            interfaceEntries => str Ź "too many interface items";
            listShort => str Ź "too few elements in list";
            listLong => str Ź "too many elements in list";

            <<warnings with no parameters>>

            pointerInit => str Ź "multiple initialization with a pointer";
            unreachable => str Ź "unreachable code";
            <<>>
            <<warnings with sei parameters>>

            paddedField => str Ź "has been padded";
            privateExport => str Ź "is private but matches an export";
            uninitialized => str Ź "appears uninitialized";
            unusedExport => str Ź "receives no exported values";
            unusedId => str Ź "is never referenced";
            unusedImport => str Ź "supplies no imported values";
            voidExport => str Ź "matches a constant in an exported interface";
                <<>>
            <<warnings with substring parameters>>

            replString => str Ź "has global strings preventing replacement";
            replId => str Ź "has incompatible attributes for replacement";
            <<>>
            <<warnings with tree parameters>>

            emptyArray => str Ź "has zero length";
            fileVersion => str Ź "referenced in different versions";
            unsignedCompare => str Ź "will use unsigned comparison";
            doubleEntry => str Ź "attempts to claim lock while the lock is held";

            <<warnings with tree parameters (and maybe others)>>
            notPortable => str Ź "may not be portable";
            looksUgly => str Ź "looks ugly";
            reallyFunky => str Ź "is really funky";

            ENDCASE;

        RETURN [ConvertUnsafe.ToRope[str]];
        };

    }.