[_CDCSL_93-16_]<1>Cedar>release>Regressions>XMesaCmplr16DefsA.mesa

File: XMesaCmplr16DefsA.mesa - created by PJ. Last edit

PJ 7-24-89 11:27:13

Foote, October 12, 1992 11:34 am PDT

XMesaCmplr16DefsA: DEFINITIONS = {

IOWR: PROC [t: CARDINAL] RETURNS [CARDINAL] = INLINE {

RETURN[t MOD 100H]};

UniversalID: TYPE [10];

ProcRecord: TYPE = RECORD[PROC];

ThisProc: ProcRecord;

maxOrgLength: CARDINAL = 3;

maxDomainLength: CARDINAL = 4;

maxLocalLength: CARDINAL = 5;

bytesPerWord: CARDINAL = 4;

nullProcess: PROCESS = NIL; -- from AR 84

Begin AR 219

Code: TYPE = BYTE;

Chset: TYPE = BYTE;

Cher: TYPE = RECORD [

chset: Chset,

code: Code];

charChouon: Cher = [chset: 11B, code: 14B];

katChouonA: Code = charChouon.code;

katChouonB: Code = 14B;

End AR 219

Begin AR 289

Char: TYPE = WORD16;

CharRep: TYPE = MSBIT WORD16 MACHINE DEPENDENT RECORD [set, code: BYTE];

Codes0: TYPE = MACHINE DEPENDENT{ null};

Sets: TYPE = MACHINE DEPENDENT { latin};

Make: PROC [set, code: BYTE] RETURNS [Char] = INLINE {

RETURN[LOOPHOLE[CharRep[set: set, code: code]]]};

nullChar: Char = Make[set: Sets.latin.ORD, code: Codes0.null.ORD];

End AR 289

Begin AR 295

RasterInfos: TYPE = POINTER TO PACKED ARRAY [0..256) OF RasterInfo;

RasterInfo: TYPE = RECORD [

leftKern: BOOLEAN,

rightKern: BOOLEAN];

End AR 295

Begin AR 304

FiledPropsRecord: <<FILEABLE>> TYPE = WORD16 MSBIT MACHINE DEPENDENT RECORD [

tabStops(0): SEQUENCE nTabStops(0): CARD16 [0..nTabsMax) OF TabStop];

nTabsMax: CARD16 = 100;

TabStop: <<FILEABLE>> TYPE = WORD16 MSBIT MACHINE DEPENDENT RECORD [

dotLeader: CARD16];

End AR 304

Begin AR 305

Offset: TYPE = INT16 [-8192..8191];

End AR 305

Begin AR 322

dataBufferSize: CARDINAL = 1024;

AugmentedStream: TYPE = POINTER TO AugmentedObj;

AugmentedObj: TYPE = RECORD [

back: ConnectionHandle,

nextToWrite: CARDINAL := 0,

nextToRead: CARDINAL := 0,

buffer: POINTER TO DataBuffer := NIL];

DataBuffer: TYPE = PACKED ARRAY [0 .. dataBufferSize) OF BYTE;

ConnectionType: TYPE = {user, server, client};

StreamState: TYPE = {idle, busy, out};

ConnectionHandle: TYPE = POINTER TO ConnectionObject;

ConnectionObject: TYPE = RECORD[

link: ConnectionHandle := NIL,

endOfRecord: BOOLEAN := FALSE,

lastMessage: BOOLEAN := FALSE,

transFilter: AugmentedObj,

bulkFilter: AugmentedObj,

type: ConnectionType,

cd: INT := -1,

streamState: StreamState := idle

];

End AR 322

ClientID: TYPE [SIZE[CARDINAL]]; -- from AR 496

Font: TYPE; -- from AR 538

Begin AR 554

XYZ: PROC [foo:CARDINAL] RETURNS [bar:CARDINAL];

Reader: TYPE = POINTER;

FError: ERROR [msg: Reader ← NIL, error: ERROR ← NIL,

errorData: POINTER TO UNSPECIFIED ← NIL];

Signal: SIGNAL [msg: Reader ← NIL, error: ERROR ← NIL,

errorData: POINTER TO UNSPECIFIED ← NIL];

End AR 554

Begin AR 557

Writer: TYPE = CARD;

InsufficientRoom: SIGNAL [needsMoreRoom: Writer, amountNeeded: CARDINAL];

End AR 557

Begin AR 637

MDRecord: TYPE = WORD8 MACHINE DEPENDENT RECORD [

a: Type6, b: Type2];

Type2: TYPE [2];

Type6: TYPE [6];

Dummy: TYPE = MACHINE DEPENDENT RECORD [a, b, c: WORD16];

Dummy2: TYPE = MACHINE DEPENDENT RECORD [a: WORD16];

valueB: Type2 = LOOPHOLE[Dummy2[a:1800]];

valueA: Type6 = LOOPHOLE[Dummy[a: 258, b: 772, c: 1286]];

End AR 637

Begin AR 933

Domain: TYPE = BASE POINTER TO DomainHeader;

DomainHeader: TYPE = RECORD [

formatVersion: CARD];

TextTable: TYPE = Domain RELATIVE POINTER [0..177777B];

assert: BOOLEAN[TRUE..TRUE] = (SIZE[TextTable] = 4);

c: CARD16 = 0;

nullText: TextTable = LOOPHOLE[CARD16[0]];

End AR 933

Begin AR 343

BitOp: TYPE = PROCEDURE [UNSPECIFIED, UNSPECIFIED] RETURNS [UNSPECIFIED];

BITAND: BitOp = MACHINE CODE { "*#define XR𡤋ITAND(a, b) ((a)&(b)).XR𡤋ITAND" };

End AR 343

THandle: TYPE [SIZE[CARD32]]; -- from AR 742

sameName: CARDINAL = 67; -- from AR 679

Begin AR 254

XAddress: TYPE = MSBIT WORD32 MACHINE DEPENDENT RECORD[

net(0:0..31): --System.--NetworkNumber,

host(0:32..79): --System.--HostNumber,

pad(0:80..95): WORD16 ← 0];

XHandle: TYPE = POINTER TO Object;

XObject: TYPE = RECORD[

variant: SELECT type: * FROM

passive => [rendezvous: CONDITION, process: PROCESS, active: XAddress],

ENDCASE];

Block: TYPE = RECORD [

blockPointer: POINTER TO PACKED ARRAY [0..0) OF BYTE,

startIndex, stopIndexPlusOne: CARD32];

ClassOfService: TYPE = {a, b, c};

NetworkAddress: TYPE = MSBIT WORD32 MACHINE DEPENDENT RECORD [

net(0:0..31): NetworkNumber,

host(0:32..79): HostNumber,

socket(0:80..95): SocketNumber];

NetworkNumber: TYPE [4];

HostNumber: TYPE [6];

SocketNumber: TYPE [2];

SHandle: TYPE = POINTER;

AddressType: TYPE =

MACHINE DEPENDENT {name(1), iso(2), tcp(3), spp(4), (LAST[CARD16])}; -- will be extended

TcpAddress: TYPE = WORD16 MACHINE DEPENDENT RECORD [

inetAddress: PACKED ARRAY [0 .. 4) OF CHARACTER,

socketnum: CARD16];

Address: TYPE = WORD16 MACHINE DEPENDENT RECORD [

addrLength(0): CARD16, -- Length of vaddr field in bytes

vaddr(1): SELECT addrType(1): AddressType FROM

name => [addrName(2) : POINTER TO CHARACTER],

spp => [addr(2): NetworkAddress],

tcp => [addr(2): TcpAddress],

iso => [dummy(2): CARD16] -- undefined

ENDCASE];

Handle: TYPE = POINTER TO READONLY Object;

Object: TYPE = RECORD [

remote: Address,

programNumber: CARD32,

versionNumber: CARD16,

zone: UNCOUNTED ZONE,

sH: SHandle,

classOfService: ClassOfService];

Create: PROCEDURE [

remote: Address,

programNumber: CARD32,

versionNumber: CARD16,

zone: UNCOUNTED ZONE,

classOfService: ClassOfService]

RETURNS [cH: Handle];

Delete: PROCEDURE [cH: Handle];

Call: PROCEDURE [

cH: Handle,

procedureNumber: CARD16,

arguments, results: Parameters := nullParameters,

requestDataStream: BOOLEAN := FALSE,

streamCheckoutProc: PROCEDURE [cH: Handle] := NIL]

RETURNS [sH: SHandle];

ReleaseDataStream: PROCEDURE [cH: Handle];

RemoteErrorSignalled: ERROR [errorNumber: CARD16, arguments: Arguments];

VersionMismatch: ERROR [versionRange: VersionRange];

VersionRange: TYPE = MACHINE DEPENDENT RECORD [low, high: CARD16];

unlimitedThreads: CARDINAL = 0; -- Constant for ExportRemoteProgram

ExportRemoteProgram: PROCEDURE [

programNumber: CARD32,

versionRange: VersionRange,

dispatcher: Dispatcher,

serviceName: STRING := NIL,

maxThreads: CARDINAL := unlimitedThreads,

zone: UNCOUNTED ZONE,

classOfService: ClassOfService];

UnexportRemoteProgram: PROCEDURE [

programNumber: CARD32, versionRange: VersionRange];

Dispatcher: TYPE = PROCEDURE [

cH: Handle,

procedureNumber: CARD16,

arguments: Arguments,

results: Results];

SignalRemoteError: ERROR [

errorNumber: CARD16, arguments: Parameters := nullParameters];

InvalidArguments: ERROR;

NoSuchProcedureNumber: ERROR;

Free: PROCEDURE [parameters: Parameters, zone: UNCOUNTED ZONE];

SerializeParameters: PROCEDURE [parameters: Parameters, sH: SHandle];

DeserializeParameters: PROCEDURE [

parameters: Parameters, sH: SHandle, zone: UNCOUNTED ZONE];

infiniteIdleTime : INT32 = -1; -- do not delete Transports

SetTransportIdleTime: PROCEDURE [ch: Handle, idleTime: INT32];

GetTransportIdleTime: PROCEDURE [ch: Handle] RETURNS [idleTime: INT32];

Error: ERROR [errorCode: ErrorCode];

ErrorCode: TYPE = {

transmissionMediumHardwareProblem, transmissionMediumUnavailable,

transmissionMediumNotReady, noAnswerOrBusy, noRouteToSystemElement,

transportTimeout, remoteSystemElementNotResponding, noCourierAtRemoteSite,

tooManyConnections, invalidMessage, noSuchProcedureNumber, returnTimedOut,

callerAborted, unknownErrorInRemoteProcedure, streamNotYours,

truncatedTransfer, parameterInconsistency, invalidArguments,

noSuchProgramNumber, protocolMismatch, duplicateProgramExport,

noSuchProgramExport, invalidHandle, internalError, noError};

Parameters: TYPE = RECORD [location: POINTER, description: Description];

nullParameters: Parameters = [NIL, NIL];

Arguments: TYPE = PROCEDURE [argumentsRecord: Parameters := nullParameters];

Results: TYPE = PROCEDURE [

resultsRecord: Parameters := nullParameters,

requestDataStream: BOOLEAN := FALSE] RETURNS [sH: SHandle];

Description: TYPE = PROCEDURE [notes: Notes];

Notes: TYPE = POINTER TO READONLY NotesObject;

NotesObject: TYPE = RECORD [

zone: UNCOUNTED ZONE, --for allocating/deallocating storage

operation: {fetch, store, free}, --being performed by description routine

noteLocation: POINTER, --defines current position in parameter area

noteUnspec16: NoteUnspec16,

noteCard16: NoteCard16,

noteInt16: NoteInt16,

noteEnum16: NoteEnum16,

noteCard32: NoteCard32,

noteInt32: NoteInt32,

noteBool: NoteBool,

noteParameters: NoteParameters,

noteChoice: NoteChoice, -- note tag for variant record

noteDeadSpace: NoteDeadSpace, --consumes portion of parameter area

noteString: NoteString, --notes Mesa STRING (NB: NIL and length = 0)

noteSpace: NoteSpace, --notes disjoint block of unspecified data

noteDynamicArray: NoteDynamicArray, --(NB: BASE = NIL or LENGTH = 0)

noteDisjointData: NoteDisjointData, --(NB: NIL)

noteBlock: NoteBlock

]; --building block for processing byte data

NoteUnspec16: TYPE = PROCEDURE [site: POINTER := NIL,

elementCnt: CARDINAL := 1];

NoteCard16: TYPE = PROCEDURE [site: POINTER TO CARD16 := NIL,

elementCnt: CARDINAL := 1];

NoteInt16: TYPE = PROCEDURE [site: POINTER TO INT16 := NIL,

elementCnt: CARDINAL := 1];

NoteEnum16: TYPE = PROCEDURE [site: POINTER := NIL,

elementCnt: CARDINAL := 1];

NoteBool: TYPE = PROCEDURE [site: POINTER TO BOOL];

NoteCard32: TYPE = PROCEDURE [site: POINTER TO CARD32 := NIL,

elementCnt: CARDINAL := 1];

NoteInt32: TYPE = PROCEDURE [site: POINTER TO INT32 := NIL,

elementCnt: CARDINAL := 1];

NoteParameters: TYPE = PROCEDURE [

site: POINTER := NIL, description: Description];

NoteChoice: TYPE = PROCEDURE [

site: POINTER := NIL] --to tag field

RETURNS[tagValue : CARD16]; -- Returns value of tag

NoteDeadSpace: TYPE = PROCEDURE [size: CARDINAL];

NoteString: TYPE = PROCEDURE [site: POINTER TO STRING := NIL];

NoteSpace: TYPE = PROCEDURE [site: POINTER, size: CARDINAL]; -- in SIZE units

NoteDynamicArray: TYPE = PROCEDURE [

site: POINTER := NIL, --to DESCRIPTOR FOR ARRAY

elementSize: CARDINAL, -- addressing units used by one element of array

upperBound: CARDINAL, --maximum number of elements permitted

dataProc: ArrayDataDescription]; -- Procedure to note the data

ArrayDataDescription: TYPE = PROCEDURE[arrDesc: POINTER TO

DESCRIPTOR FOR ARRAY OF UNSPECIFIED, notes: Notes];

NoteDisjointData: TYPE = PROCEDURE [

site: POINTER TO POINTER := NIL, description: Description, size: CARDINAL];

NoteBlock: TYPE = PROCEDURE [block: Block];

LocalSystemElement: PROCEDURE[addrType: AddressType := spp]

RETURNS [localSystemElement: Address];

End AR 254

Begin AR 1071

LineSeq: TYPE = LONG POINTER TO LineSeqBody;

LineSeqBody: TYPE = RECORD[ix: CARDINAL];

Ptformatctxt: TYPE = LONG POINTER TO Formatctxt;

Formatctxt: TYPE = RECORD [ixline: CARD16];

PaginationContext: TYPE = LONG POINTER TO AqPaginationContext;

Ht: TYPE = INT16;

Aqline: TYPE = WORD16 MSBIT MACHINE DEPENDENT RECORD [

htLineComp: Ht];

AqPaginationContext: TYPE = RECORD [

htOfFramesInText: CARDINAL ← 0,

aqline: Aqline,

formatctxt: Ptformatctxt ← NIL,

lineSeq: LineSeq ← NIL

];

End AR 1071

Begin AR 1064

MediaHandle: TYPE[SIZE[POINTER]];

End AR 1064

Begin AR 1185

lock: MONITORLOCK;

Handle2:TYPE = POINTER TO Object2;

Object2: TYPE = RECORD[

inTree: BOOLEAN

];

NegativeSteepLine: PROC [window: Handle2];

BITAND2: PROC [UNSPECIFIED, UNSPECIFIED] RETURNS [UNSPECIFIED] = INLINE {RETURN[0]};

end AR 1185

begin AR 1474

HHandle: TYPE [SIZE[POINTER]];

end AR 1474

}..