-- fortytwo.mesa
-- Please do not edit this file.
-- It was generated using CedarRPCGen.

DIRECTORY
  Rope,
  Arpa,
  fortyone,
  fourtwo,
  SunRPCAuth,
  SunRPC;

fortytwo: CEDAR DEFINITIONS =
BEGIN

ROPE: TYPE = Rope.ROPE;


QuestionType: TYPE = MACHINE DEPENDENT {
	boring(123),
	cosmic(456),
	universal(457),
	stupid(789),
	silly(790)
	};

Question1Type: TYPE = MACHINE DEPENDENT {
	boooring(0),
	cooosmic(1),
	univeeersal(2),
	stuuupid(3),
	sillly(4)
	};

Question1TypeNames: READONLY ARRAY Question1Type OF ROPE;

answerRecType: TYPE = fourtwo.answerRec;

TheANSWER: TYPE = REF TheANSWERObject;
TheANSWERObject: TYPE = RECORD [
	union: SELECT truthType: QuestionType FROM
	  boring => [b: PACKED ARRAY [0..13) OF BYTE],
	  cosmic => [c: INT32],
	  stupid => [],
	  silly, universal => [d: REF fourtwo.answerRec],
	  ENDCASE];

YetAnotherAnswer: TYPE = REF YetAnotherAnswerObject;
YetAnotherAnswerObject: TYPE = RECORD [
	responseType: INT32,
	union: SELECT uTag: * FROM
	  v0 => [answer: QuestionType],
	  v1 => [a: INT32],
	  default => [],
	  ENDCASE];

trueAnswerRec: TYPE = RECORD [
 tellingTheTruth: BOOLEAN,
 theTruth: PACKED ARRAY [0..fortyone.TRUTHSIZE) OF INT32,
 theTRUTH: TheANSWER
	];

trueQuestionRec: TYPE = RECORD [
 questionType: QuestionType,
 randomNumbers: SeqType0
	];

SeqType0: TYPE = REF SeqType0Object;
SeqType0Object: TYPE = RECORD [SEQUENCE size: [0..LAST[INT32]) OF INT32];

QuestionRec: TYPE = trueQuestionRec;

AnswerRec: TYPE = trueAnswerRec;

QuestionRecPtr: TYPE = REF QuestionRec;

QuestionRecArray: TYPE = SeqType1;

SeqType1: TYPE = REF SeqType1Object;
SeqType1Object: TYPE = RECORD [SEQUENCE size: [0..LAST[INT32]) OF QuestionRec];

QuestionRecArray1: TYPE = PACKED ARRAY [0..13) OF QuestionRec;

tuple: TYPE = RECORD [
 x: INT32,
 y: INT32
	];

randomTypes: TYPE = RECORD [
 a: REAL,
 b: DREAL,
 c: BYTE,
 d: INT16,
 e: INT32,
 f: INT32,
 g: BYTE,
 h: CARD16,
 i: CARD32,
 j: CARD32,
 k: SeqType2,
 l: PACKED ARRAY [0..3) OF BYTE,
 m: SeqType3
	];

SeqType3: TYPE = REF SeqType3Object;
SeqType3Object: TYPE = RECORD [SEQUENCE size: [0..LAST[INT32]) OF BYTE];

SeqType2: TYPE = REF SeqType2Object;
SeqType2Object: TYPE = RECORD [SEQUENCE size: [0..LAST[INT32]) OF tuple];

FooBar: TYPE = INT32;

foo: TYPE = REF fooObject;
fooObject: TYPE = RECORD [
	desc: CARD32,
	union: SELECT uTag: * FROM
	  v1 => [a: CARD32],
	  v2 => [b: SeqType4],
	  v3 => [c: PACKED ARRAY [0..42) OF BYTE],
	  v4 => [d: SeqType5],
	  default => [e: BYTE],
	  ENDCASE];

SeqType5: TYPE = REF SeqType5Object;
SeqType5Object: TYPE = RECORD [SEQUENCE size: [0..LAST[INT32]) OF CARD32];

SeqType4: TYPE = REF SeqType4Object;
SeqType4Object: TYPE = RECORD [SEQUENCE size: [0..LAST[INT32]) OF CARD32];

barr: TYPE = RECORD [
 a: CARD16,
 b: SeqType6,
 c: PACKED ARRAY [0..13) OF BYTE,
 d: REF CARD32
	];

SeqType6: TYPE = REF SeqType6Object;
SeqType6Object: TYPE = RECORD [SEQUENCE size: [0..LAST[INT32]) OF CARD32];

ULONG: TYPE = CARD32;

foobar: TYPE = SeqType7;

SeqType7: TYPE = REF SeqType7Object;
SeqType7Object: TYPE = RECORD [SEQUENCE size: [0..LAST[INT32]) OF CARD32];

foobaz: TYPE = PACKED ARRAY [0..137) OF BYTE;

foobarrr: TYPE = REF CARD32;

bar: TYPE = REF barObject;
barObject: TYPE = RECORD [
	union: SELECT desc: BOOLEAN FROM
	  TRUE => [a: INT32],
	  FALSE => [b: BYTE],
	  ENDCASE];

TestNamesArray: TYPE = MACHINE DEPENDENT {
	a(1),
	b(2)
	};

FORTYTWOPROG: CARDINAL = 20000000H;

FORTYTWOVERS1: CARDINAL = 1;

getanswerProc: TYPE = PROC[o: FORTYTWOPROG1,
                theQuestion: ROPE,
                aRandomNumber: CARD16,
                anotherQuestion: REF TEXT]
		RETURNS [res: fourtwo.answerRec];
gettrueanswerProc: TYPE = PROC[o: FORTYTWOPROG1,
                questionType: QuestionType,
                randomNumbers: SeqType0]
		RETURNS [res: trueAnswerRec];
getbogusanswerProc: TYPE = PROC[o: FORTYTWOPROG1]
		RETURNS [res: INT32];
dontanswerProc: TYPE = PROC[o: FORTYTWOPROG1, in: INT32];

FORTYTWOPROG1: TYPE =  REF FORTYTWOPROG1Object;
FORTYTWOPROG1Object: TYPE = RECORD [
  getanswer: getanswerProc,
  gettrueanswer: gettrueanswerProc,
  getbogusanswer: getbogusanswerProc,
  dontanswer: dontanswerProc,
  rpcHandle: SunRPC.Handle _ NIL,
  rpcConversation: SunRPCAuth.Conversation _ NIL,
  data: REF ANY _ NIL
  ];

MakeFORTYTWOPROG1Client: PROC[h: SunRPC.Handle,
	c: SunRPCAuth.Conversation] RETURNS [FORTYTWOPROG1];
MakeFORTYTWOPROG1Server: PROC[
  data: REF,
  getanswer: getanswerProc,
  gettrueanswer: gettrueanswerProc,
  getbogusanswer: getbogusanswerProc,
  dontanswer: dontanswerProc
  ] RETURNS [SunRPC.Server];


FORTYTWOVERS2: CARDINAL = 2;

gettheanswerProc: TYPE = PROC[o: FORTYTWOPROG2,
                questionType: QuestionType,
                randomNumbers: SeqType0]
		RETURNS [res: AnswerRec];

FORTYTWOPROG2: TYPE =  REF FORTYTWOPROG2Object;
FORTYTWOPROG2Object: TYPE = RECORD [
  gettheanswer: gettheanswerProc,
  rpcHandle: SunRPC.Handle _ NIL,
  rpcConversation: SunRPCAuth.Conversation _ NIL,
  data: REF ANY _ NIL
  ];

MakeFORTYTWOPROG2Client: PROC[h: SunRPC.Handle,
	c: SunRPCAuth.Conversation] RETURNS [FORTYTWOPROG2];
MakeFORTYTWOPROG2Server: PROC[
  data: REF,
  gettheanswer: gettheanswerProc
  ] RETURNS [SunRPC.Server];


TESTTYPESPROG: CARDINAL = 40400001;

TESTTYPES3: CARDINAL = 3;

dotestProc: TYPE = PROC[o: TESTTYPESPROG3,
                a: REAL,
                b: DREAL,
                c: BYTE,
                d: INT16,
                e: INT32,
                f: INT32,
                g: BYTE,
                h: CARD16,
                i: CARD32,
                j: CARD32,
                k: SeqType2,
                l: PACKED ARRAY [0..3) OF BYTE,
                m: SeqType3]
		RETURNS [res: randomTypes];

TESTTYPESPROG3: TYPE =  REF TESTTYPESPROG3Object;
TESTTYPESPROG3Object: TYPE = RECORD [
  dotest: dotestProc,
  rpcHandle: SunRPC.Handle _ NIL,
  rpcConversation: SunRPCAuth.Conversation _ NIL,
  data: REF ANY _ NIL
  ];

MakeTESTTYPESPROG3Client: PROC[h: SunRPC.Handle,
	c: SunRPCAuth.Conversation] RETURNS [TESTTYPESPROG3];
MakeTESTTYPESPROG3Server: PROC[
  data: REF,
  dotest: dotestProc
  ] RETURNS [SunRPC.Server];


END.