-- File: TFI3dImpl.mesa (text file in for 3d)
-- Last edited by Bier on July 6, 1983 4:28 pm
-- Contents: convenience functions for parsing low-level parts of a 3d fileout produced by fileout3d.mesa

DIRECTORY
	GraphicsColor,
	IO,
	Matrix3d,
	Rope,
	SVArtwork,
	SVVector3d,
	SVMappings,
	SVMatrix2d,
	TFI3d;

TFI3dImpl: PROGRAM
	IMPORTS GraphicsColor, IO, Matrix3d, SVArtwork, SVMappings, SVMatrix2d, Rope
	EXPORTS TFI3d =
	
BEGIN

Color: TYPE = GraphicsColor.Color;
Matrix3by3: TYPE = SVMatrix2d.Matrix3by3;
Matrix4by4: TYPE = Matrix3d.Matrix4by4;
OMap: TYPE = SVArtwork.OMap;
Point3d: TYPE = Matrix3d.Point3d;
Point2d: TYPE = Matrix3d.Point2d;
Vector: TYPE = SVVector3d.Vector;
Material: TYPE = SVArtwork.Material;
SMap: TYPE = SVArtwork.SMap;
CharClass: TYPE = IO.CharClass;
	-- {break, sepr, other}

FileinMatrix: PUBLIC PROC [f: IO.STREAM] RETURNS [mat: Matrix4by4] = {
	mat _ Matrix3d.Identity[];
	ReadRope[f, "["];
	ReadBlankAndRope[f, "["];
	mat[1][1] _ ReadBlankAndReal[f];
	FOR j: NAT IN[2..4] DO
		ReadBlankAndRope[f,","];
		mat[1][j] _ ReadBlankAndReal[f];
	ENDLOOP;
	ReadBlank[f];
	ReadBlankAndRope[f, "]"];
	FOR i: NAT IN[2..3] DO
		ReadBlankAndRope[f, ","];
		ReadBlankAndRope[f, "["];
		mat[i][1] _ ReadBlankAndReal[f];
		FOR j: NAT IN[2..4] DO
			ReadBlankAndRope[f, ","];
			mat[i][j] _ ReadBlankAndReal[f];
		ENDLOOP;
		ReadBlankAndRope[f, "]"];
	ENDLOOP;
	ReadBlankAndRope[f, "]"];
	};	-- end of FileinMatrix
	
FileinMatrix3by3: PUBLIC PROC [f: IO.STREAM] RETURNS [mat: Matrix3by3] = {
	mat _ SVMatrix2d.Identity[];
	ReadRope[f, "["];
	ReadBlankAndRope[f, "["];
	mat[1][1] _ ReadBlankAndReal[f];
	FOR j: NAT IN[2..3] DO
		ReadBlankAndRope[f,","];
		mat[1][j] _ ReadBlankAndReal[f];
	ENDLOOP;
	ReadBlank[f];
	ReadBlankAndRope[f, "]"];
	ReadBlankAndRope[f, ","];
	ReadBlankAndRope[f, "["];
	mat[2][1] _ ReadBlankAndReal[f];
	FOR j: NAT IN[2..3] DO
		ReadBlankAndRope[f, ","];
		mat[2][j] _ ReadBlankAndReal[f];
	ENDLOOP;
	ReadBlankAndRope[f, "]"];
	ReadBlankAndRope[f, "]"];
	};	-- end of FileinMatrix3by3

ReadRope: PUBLIC PROC [f: IO.STREAM, rope: Rope.ROPE] = {
	-- removes the given rope from the top of the stream. Used to remove formatting words and phrases from 3d files.  We are not interested in these strings but only in the data in between them.
	-- Signals RopeNotOnTop if some other rope is on top.
	c: CHAR;
	FOR i: NAT IN[1..Rope.Length[rope]] DO
		c _ IO.GetChar[f];
		IF NOT c = Rope.Fetch[rope,i-1] THEN 
				SIGNAL RopeNotOnTop [IO.GetIndex[f], Rope.FromChar[c], rope];
	ENDLOOP;
	};
RopeNotOnTop: PUBLIC SIGNAL [position: NAT, wasThere: Rope.ROPE, notThere: Rope.ROPE] = CODE;

ReadChar: PUBLIC PROC [f: IO.STREAM, c: CHAR] = {
	streamC: CHAR _ IO.GetChar[f];
	IF NOT c = streamC THEN SIGNAL RopeNotOnTop[IO.GetIndex[f], Rope.FromChar[streamC], Rope.FromChar[c]];
	};

ReadReturn: PUBLIC PROC [f: IO.STREAM] = {
	-- convenience function.  Equivalent to ReadChar[f, IO.CR];
	ReadChar[f, IO.CR];
	};

WordBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = CHECKED {
	SELECT char FROM
	IO.TAB => RETURN [break];
	IO.CR =>RETURN [break];
	IO.SP => RETURN [break];
	', => RETURN [break];
	'] => RETURN [break];
	') => RETURN [break];
	ENDCASE => RETURN [other];
	};
	
KeyWordBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = CHECKED {
	SELECT char FROM
	IO.CR =>RETURN [break];
	': => RETURN [break];
	ENDCASE => RETURN [other];
	};

ReadWord: PUBLIC PROC [f: IO.STREAM] RETURNS [word: Rope.ROPE] = {
	-- reads a rope until <SPACE>, <CR>, <COMMA> or <TAB> are encountered.  Used to read in a rope which is data.  ie the name of a coordinate system from a 3d file.
	word _ IO.GetToken[f, WordBreakProc];
	};

ReadKeyWord: PUBLIC PROC [f: IO.STREAM] RETURNS [keyWord: Rope.ROPE, good: BOOL] = {
	-- reads a rope until a ':' or <CR> are encountered.  If CR is encountered first, then good is FALSE since ":" is expected after a keyword.
	nextChar: Rope.ROPE;
	keyWord _ IO.GetToken[f, KeyWordBreakProc];
	nextChar _ IO.GetToken[f, KeyWordBreakProc];
	good _ Rope.Equal[nextChar, ":", TRUE];
	};
	
LineBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = CHECKED {
	SELECT char FROM
	IO.CR =>RETURN [break];
	ENDCASE => RETURN [other];
	};
	
ReadLine: PUBLIC PROC [f: IO.STREAM] RETURNS [line: Rope.ROPE] = {
	-- reads a rope UNTIL <CR> is encountered.  Used to read Solidviews version rope
	line _ IO.GetToken[f, LineBreakProc];
	[] _ IO.GetToken[f, LineBreakProc]; -- remove <CR>
	};
	
WhiteSpaceProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
	SELECT char FROM
	IO.TAB => RETURN [other];
	IO.CR =>RETURN [other];
	IO.SP => RETURN [other];
	ENDCASE => RETURN [break];
	};

ReadWhiteSpace: PUBLIC PROC [f: IO.STREAM] = {
	-- reads, <SPACE>'s, <CR>'s, and <TAB>'s until something else is encountered.  Signals RopeNotOnTop if no white space characters are found.
	whiteSpace: Rope.ROPE _ IO.GetToken[f, WhiteSpaceProc];
	IF Rope.Size[whiteSpace] = 0 THEN SIGNAL RopeNotOnTop[IO.GetIndex[f], "null", "<whitespace>"];
	};

ReadBlank: PUBLIC PROC [f: IO.STREAM] = {
	-- reads, <SPACE>'s, <CR>'s, and <TAB>'s until something else is encountered.  Doesn't mind if no white space characters are found.
	whiteSpace: Rope.ROPE;
	len: NAT;
	c: CHAR;
	whiteSpace _ IO.GetSequence[f, BlankProc];
	len _ Rope.Size[whiteSpace];
	IF len # 0 THEN {
		c _ Rope.Fetch[whiteSpace, len-1];
		IO.Backup[f, c];
		RETURN;
		};
	};
	
BlankProc: SAFE PROC [char: CHAR] RETURNS [quit: BOOL _ FALSE, include: BOOL _ TRUE] = TRUSTED {
	SELECT char FROM
	IO.CR, IO.TAB, IO.SP => RETURN [FALSE, TRUE];
	ENDCASE => RETURN [TRUE, TRUE];
	};
	
ReadHorizontalBlank: PUBLIC PROC [f: IO.STREAM] RETURNS [good: BOOL] = {
	-- reads <SPACE>'s, and <TABS>'s until something else is encountered.  Returns good = FALSE if a CR is encountered before anything else
	whiteSpace: Rope.ROPE;
	len: NAT;
	c: CHAR;
	good _ TRUE;
	whiteSpace _ IO.GetSequence[f, HorizontalBlankProc];
	len _ Rope.Size[whiteSpace];
	IF len # 0 THEN {
		c _ Rope.Fetch[whiteSpace, len-1];
		IF c = IO.CR THEN good _ FALSE;
		IO.Backup[f, c];
		RETURN;
		};
	};
	
HorizontalBlankProc: SAFE PROC [char: CHAR] RETURNS [quit: BOOL _ FALSE, include: BOOL _ TRUE] = TRUSTED {
	SELECT char FROM
	IO.TAB, IO.SP => RETURN [FALSE, TRUE];
	ENDCASE => RETURN [TRUE, TRUE];
	};

ReadBlankAndRope: PUBLIC PROC [f: IO.STREAM, rope: Rope.ROPE] = {
	ReadBlank[f];
	ReadRope[f, rope];
	};
	
ReadBlankAndReal: PUBLIC PROC [f: IO.STREAM] RETURNS [r: REAL] = {
	-- a convenience function.  Equivalent to ReadBlank[f]; r _ ReadReal[f];
	ReadBlank[f];
	r _ ReadReal[f];
	};
	
ReadBlankAndWord: PUBLIC PROC [f: IO.STREAM] RETURNS [word: Rope.ROPE] = {
	-- a convenience function.  Equivalent to ReadBlank[f]; word _ ReadWord[f];
	ReadBlank[f];
	word _ ReadWord[f];
	};

ReadBlankAndNAT: PUBLIC PROC [f: IO.STREAM] RETURNS [n: NAT] = {
	-- a convenience function.  Equivalent to ReadBlank[f]; n _ ReadNAT[f];
	ReadBlank[f];
	n _ ReadNAT[f];
	};
	
ReadPoint3d: PUBLIC PROC [f: IO.STREAM] RETURNS [point3d: Point3d] = {
	-- assumes the next rope on the stream will be of the form "[<real1>,<real2>,<real3>]".
	ReadRope[f, "["];
	point3d[1] _ ReadBlankAndReal[f];
	ReadRope[f, ","];
	point3d[2] _ ReadBlankAndReal[f];
	ReadRope[f, ","];
	point3d[3] _ ReadBlankAndReal[f];
	ReadRope[f, "]"];
	};
	
ReadPoint2d: PUBLIC PROC [f: IO.STREAM] RETURNS [point2d: Point2d] = {
	-- assumes the next rope on the stream will be of the form "[<real1>,<real2>]".
	ReadRope[f, "["];
	point2d[1] _ ReadBlankAndReal[f];
	ReadRope[f, ","];
	point2d[2] _ ReadBlankAndReal[f];
	ReadRope[f, "]"];
	};
	
ReadPoint2dAsPoint3d: PUBLIC PROC [f: IO.STREAM] RETURNS [point3d: Point3d] = {
	-- assumes the next rope on the stream will be of the form "[<real1>,<real2>]".  Fills in point3d[3] with zero.
	ReadRope[f, "["];
	point3d[1] _ ReadBlankAndReal[f];
	ReadRope[f, ","];
	point3d[2] _ ReadBlankAndReal[f];
	point3d[3] _ 0;
	ReadRope[f, "]"];
	};

RealBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
	SELECT char FROM
	'], ', => RETURN [break];
	IO.CR =>RETURN [break];
	IO.SP => RETURN [break];
	ENDCASE => RETURN [other];
	};
	
ReadReal: PUBLIC PROC [f: IO.STREAM] RETURNS [r: REAL] = {
	-- reads digits up to the next ], <CR>, <SPACE> or <COMMA>.  Leaves these terminators on the stream.
	realRope: Rope.ROPE _ IO.GetToken[f, RealBreakProc];
	IF Rope.Find[realRope, ".", 0, FALSE] = -1 THEN realRope _ Rope.Concat[realRope, ".0"];
	r _ IO.GetReal[IO.RIS[realRope]];
	};
	
NATBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
	SELECT char FROM
	'], IO.CR, IO.SP, '., ', => RETURN [break];
	ENDCASE => RETURN [other];
	};
	
ReadNAT: PUBLIC PROC [f: IO.STREAM] RETURNS [n: NAT] = {
	-- reads digits up to the next ], <CR>, <SPACE>.  Leaves these terminators on the stream.
	intRope: Rope.ROPE _ IO.GetToken[f, NATBreakProc];
	n _ IO.GetInt[IO.RIS[intRope]];
	};

BoolBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
	SELECT char FROM
	'], IO.CR, IO.SP, '., ', => RETURN [break];
	ENDCASE => RETURN [other];
	};

ReadBool: PUBLIC PROC [f: IO.STREAM] RETURNS [truth: BOOL, good: BOOL] = {
	-- tries to read TRUE or FALSE from the stream.  If it encounters another word, good = FALSE;
	boolRope: Rope.ROPE _ IO.GetToken[f, BoolBreakProc];
	good _ TRUE;
	IF Rope.Equal[boolRope, "TRUE", TRUE] THEN {
		truth _ TRUE}
	ELSE IF Rope.Equal[boolRope, "FALSE", TRUE] THEN {
		truth _ FALSE}
	ELSE {truth _ FALSE; good _ FALSE};
	};

ReadColor: PUBLIC PROC [f: IO.STREAM] RETURNS [color: Color] = {
	r, g, b: REAL;
	ReadChar[f, '[];
	r _ ReadBlankAndReal[f];
	ReadChar[f, ',];
	g _ ReadBlankAndReal[f];
	ReadChar[f, ',];
	b _ ReadBlankAndReal[f];
	ReadChar[f, ']];
	color _ GraphicsColor.RGBToColor[r, g, b];
	};	-- end of ReadColor
	
ReadSurface: PUBLIC PROC [f: IO.STREAM] RETURNS [surface: REF ANY] = {
	surfType: Rope.ROPE _ ReadBlankAndWord[f];
	SELECT TRUE FROM
		Rope.Equal[surfType, "tube", FALSE] => {
			radius, height: REAL;
			ReadBlankAndRope[f, "[radius:"];
			radius _ ReadBlankAndReal[f];
			ReadBlankAndRope[f, ","];
			ReadBlankAndRope[f, "height:"];
			height _ ReadBlankAndReal[f];
			ReadBlankAndRope[f, "]"];
			surface _ SVMappings.CreateTube[radius, height];
			};
		Rope.Equal[surfType, "box", FALSE] => {
			boxSide: Vector;
			ReadBlank[f];
			boxSide _ ReadPoint3d[f];
			surface _ SVMappings.CreateBox[boxSide[1], boxSide[2], boxSide[3]];
			};
		Rope.Equal[surfType, "NIL"] => {};
	ENDCASE => ERROR;
	};	-- end of ReadSurface

ReadMaterial: PUBLIC PROC [f: IO.STREAM] RETURNS [material: Material] = {
	matRope: Rope.ROPE _ ReadWord[f];
	success: BOOL;
	[material, success] _ SVArtwork.RopeToMaterial[matRope];
	IF NOT success THEN ERROR;
	};

ReadSMap: PUBLIC PROC [f: IO.STREAM] RETURNS [sMap: SMap] = {
	mapRope: Rope.ROPE _ ReadWord[f];
	success: BOOL;
	[sMap, success] _ SVArtwork.RopeToSMap[mapRope];
	IF NOT success THEN ERROR;
	};

ReadOMap: PUBLIC PROC [f: IO.STREAM] RETURNS [oMap: OMap] = {
	mapRope: Rope.ROPE _ ReadWord[f];
	success: BOOL;
	[oMap, success] _ SVArtwork.RopeToOMap[mapRope];
	IF NOT success THEN ERROR;
	};
	
END.
Κ{–
"Mesa" style˜Iprocš˜ΟcΗ
œ
Οk	œžœ[žœžœžœ5žœžœ	žœ$žœ&žœžœžœžœžœ žœžœžœžœ
œœ
Οnœžœ
žœžœ
žœžœ„
žœžœ
žœžœ@žœ-žœžœ
žœžœ^žœžœ
žœžœDžœžœ!œŸœžœ
žœžœ
žœžœ†
žœžœ
žœžœ@žœ…
žœžœ
žœžœAžœ<œ
Ÿœžœ
žœžœ
žœ
žœΏ
œ
6œžœžœžœ
žœžœžœžœ
žœžœžœžœ(žœžœ
žœžœžœžœžœŸœžœ
žœžœ
žœžœžœžœžœ
žœ
žœ
žœžœ>Ÿ
œžœ
žœžœ
žœ<œ
žœ
žœŸ
œžœ
žœžœžœžœžœžœžœžœ
žœžœžœ
žœžœžœ
žœžœžœžœžœžœžœŸœžœ
žœžœžœžœžœžœžœžœ
žœžœžœžœžœŸœžœ
žœžœ
žœžœ
žœ’
œžœ"Ÿœžœ
žœžœ
žœžœžœžœ
œžœ
žœ,žœBžœ	Ÿ
œžœ
žœžœžœžœžœžœžœžœ
žœžœžœžœŸœžœ
žœžœ
žœžœ
žœQœžœ#žœ2Ÿœžœ
žœžœžœžœžœžœžœžœ
žœžœžœ
žœžœžœ
žœžœžœžœŸœžœ
žœžœ
žœŒ
œžœžœžœžœ
žœžœ,Ÿ	œžœ
žœžœ
žœ„
œžœžœžœžœ;žœ	žœ*žœžœ
Ÿ	œžœ
žœžœžœžœžœžœžœžœžœžœžœ
žœžœ
žœžœ
žœžœžœžœžœžœžœžœ	Ÿœžœžœ
žœžœžœŠ
œžœžœžœ
žœžœEžœ	žœ*žœžœ
žœ
žœžœžœžœ
Ÿœžœ
žœžœžœžœžœžœžœžœžœžœžœ
žœžœ
žœžœžœžœžœžœžœžœŸœžœ
žœžœ
žœ
žœ/Ÿœžœ
žœžœ
žœžœžœIœ'Ÿœžœ
žœžœ
žœžœ
žœLœ)Ÿœžœ
žœžœ
žœžœžœHœ&Ÿœžœ
žœžœ
žœžœXœ»
Ÿœžœ
žœžœ
žœžœPœ…
Ÿœžœ
žœžœ
žœžœpœ•
Ÿ
œžœ
žœžœžœžœžœžœžœžœžœ
žœžœžœ
žœžœžœžœŸœžœ
žœžœ
žœžœžœeœžœžœžœžœžœ.žœ	žœ
žœŸœžœ
žœžœžœžœžœžœžœžœ
žœžœ
žœžœžœžœŸœžœ
žœžœ
žœžœžœZœžœžœ!žœžœ
žœŸ
œžœ
žœžœžœžœžœžœžœžœ
žœžœ
žœžœžœžœ
Ÿ
œžœ
žœžœ
žœžœ	žœžœ^œžœžœ%žœžœžœžœ
žœžœ
žœžœžœ
žœžœ
žœ	žœ˜ΥIKšœ
Ÿ	œžœ
žœžœ
žœžœžœΘ
œŸœžœ
žœžœ
žœžœžœ
žœžœžœ
žœ
žœ žœžœžœΌ
žœžœœ
Ÿœžœ
žœžœ
žœžœ)žœžœ=žœ
žœ	žœ
žœŸœžœ
žœžœ
žœžœ!žœžœ5žœ
žœ	žœ
žœŸœžœ
žœžœ
žœžœ!žœžœ5žœ
žœ	žœ
žœžœ
˜ε—…—+>3Ώ