[_CDCSL_93-16_]<1>Cedar>release>MimosaOnly>MessageTabImpl.mesa

MessageTabImpl.mesa

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]];

};