/*****************************************************************************
* "Irit" - the 3d polygonal solid modeller. *
* *
* Written by: Gershon Elber Ver 0.2, Mar. 1990 *
******************************************************************************
* Data File Interpreter module - handle data files - to/from geom objects *
*****************************************************************************/
#ifdef USE_VARARGS
#include <varargs.h>
#else
#include <stdarg.h>
#endif /* USE_VARARGS */
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <string.h>
#include "program.h"
#include "cagd_lib.h"
#include "allocate.h"
#include "attribut.h"
#include "dataprsr.h" /* Visible to the other modules. */
#include "geomat3d.h"
#include "objects.h"
#include "windows.h"
#include "graphgen.h"
#define UNGET_STACK_SIZE 5 /* Internal stack size. */
typedef enum { /* List of all possible tokens enumerated. */
TOKEN_NONE,
TOKEN_OPEN_PAREN,
TOKEN_CLOSE_PAREN,
TOKEN_E2,
TOKEN_P2,
TOKEN_E3,
TOKEN_P3,
TOKEN_NUMBER,
TOKEN_STRING,
TOKEN_VECTOR,
TOKEN_MATRIX,
TOKEN_CTLPT,
TOKEN_VERTEX,
TOKEN_POLYGON,
TOKEN_POLYLINE,
TOKEN_OBJECT,
TOKEN_COLOR,
TOKEN_INTERNAL,
TOKEN_NORMAL,
TOKEN_PLANE,
TOKEN_CURVE,
TOKEN_SURFACE,
TOKEN_OTHER = 100, /* Probably names & numbers. */
TOKEN_EOF = -1
} TokenType;
typedef enum { /* Possible error code during data parsing. */
DP_NO_ERR = 0,
DP_ERR_NUMBER_EXPECTED,
DP_ERR_OPEN_PAREN_EXPECTED,
DP_ERR_CLOSE_PAREN_EXPECTED,
DP_ERR_LIST_COMP_UNDEF,
DP_ERR_UNDEF_EXPR_HEADER,
DP_ERR_PT_TYPE_EXPECTED,
DP_ERR_OBJECT_EMPTY,
DP_ERR_EMPTY_NAME,
DP_ERR_OPEN_FAILED,
DP_ERR_MIXED_TYPES,
DP_STR_NOT_IN_QUOTES,
DP_ERR_CAGD_LIB_ERR,
DP_WRN_OBJ_NAME_TRUNC = 100
} DataPrsrErrType;
static int DPGlblLineCount = 0; /* Used to locate errors in input file. */
static DataPrsrErrType DPGlblParserError = DP_NO_ERR; /* Last err # found. */
static char DPGlblTokenError[LINE_LEN]; /* Last token where error was found. */
static jmp_buf LclLongJumpBuffer; /* Used in error traping. */
static int GlblToken = 0, /* Used by the parser, to unget token. */
GlblLineCount = 1; /* Used to locate errors in input file. */
static char GlblStringToken[UNGET_STACK_SIZE][LINE_LEN];/* Save unget tokens.*/
static FILE *OutputFile = NULL;
static void UnGetToken(char *StringToken);
static void GetStringToken(FILE *f, char *StringToken);
static TokenType GetToken(FILE *f, char *StringToken);
static void GetVertexAttributes(VertexStruct *PVertex, FILE *f,
int *HasNormal);
static void GetPolygonAttributes(PolygonStruct *PPolygon, FILE *f,
int *HasPlane);
static void GetObjectAttributes(ObjectStruct *PObject, FILE *f);
static void GetPointData(FILE *f, PolygonStruct *PPolygon, int IsPolyline,
int *HasNormal);
static void DPUpdatePolyPlane(PolygonStruct *PPoly);
static void ParserError(DataPrsrErrType ErrNum, char *Msg);
static void DataPrsrPutAllObjects(ObjectStruct *PObj, int Indent);
static char *Real2Str(RealType R);
static void DataPrsrGetAllObjects(FILE *f, ObjectStruct *PObjParent);
static void GetCloseParenToken(FILE *f);
static void GetNumericToken(FILE *f, RealType *r);
static void DataPrsrGetAuxObject(FILE *f, ObjectStruct *PObj);
#ifdef USE_VARARGS
static void IFprintf(int Indent, char *va_alist, ...);
#else
static void IFprintf(int Indent, char *Format, ...);
#endif /* USE_VARARGS */
/*****************************************************************************
* Routine to print the data from given object into given file FileName. *
* If FileName is NULL or empty, print to screen using WndwInputWindowPutStr. *
*****************************************************************************/
void DataPrsrPutObject(char *FileName, ObjectStruct *PObj)
{
char *Pchar;
char FullFileName[LINE_LEN];
DPGlblParserError = DP_NO_ERR;
/* If the following gain control and is non zero - its from error! */
if (setjmp(LclLongJumpBuffer) != 0) {
if (OutputFile != NULL) fclose(OutputFile);
return;
}
if (FileName && (int) strlen(FileName) > 0) {
if ((Pchar = strchr(FileName, '.')) != NULL)
*Pchar = 0; /* Make sure no file type is given. */
if (strlen(FileName) == 0) ParserError(DP_ERR_EMPTY_NAME, "");
strcpy(FullFileName, FileName);
strcat(FullFileName, ".dat");
if ((OutputFile = fopen(FullFileName, "w")) == NULL)
ParserError(DP_ERR_OPEN_FAILED, FullFileName);
}
else
OutputFile = NULL;
DataPrsrPutAllObjects(PObj, 0);
if (OutputFile) {
fclose(OutputFile);
OutputFile = NULL;
}
return;
}
/*****************************************************************************
* Routine to read the data from a given file. *
*****************************************************************************/
ObjectStruct *DataPrsrGetObjects(char *FileName)
{
char FullFileName[LINE_LEN];
FILE
*f = NULL;
ObjectStruct *PObj, *PTmp;
/* If the following gain control and is non zero - its from error! */
if (setjmp(LclLongJumpBuffer) != 0) {
if (f != NULL) fclose(f);
return NULL;
}
if (strlen(FileName) == 0) ParserError(DP_ERR_EMPTY_NAME, "");
strcpy(FullFileName, FileName);
if (strrchr(FullFileName, '.') == NULL) strcat(FullFileName, ".dat");
if ((f = fopen(FullFileName, "r")) == NULL)
ParserError(DP_ERR_OPEN_FAILED, FullFileName);
GlblToken = 0; /* Used in UnGetToken token buffer. */
DPGlblParserError = DP_NO_ERR; /* Reset errors. */
GlblLineCount = 1; /* Reset line counter. */
PObj = AllocObject("", OBJ_LIST_OBJ, NULL);
DataPrsrGetAllObjects(f, PObj);
if (PObj -> ObjType == OBJ_LIST_OBJ &&
PObj -> U.PObjList[1] == NULL)
{
/* Only one object in list - return the object instead. */
PTmp = PObj -> U.PObjList[0];
PObj -> U.PObjList[0] = NULL;
MyFree((char *) PObj, ALLOC_OBJECT);
PObj = PTmp;
}
fclose(f);
return PObj;
}
/*****************************************************************************
* Same as fprintf but with indentation. Prints into global OutputFile unless *
* it is NULL in which it prints to screen using WndwInputWindowPutStr *
*****************************************************************************/
#ifdef USE_VARARGS
static void IFprintf(int Indent, char *va_alist, ...)
{
char *Format, Line[LINE_LEN_LONG];
int i;
va_list ArgPtr;
va_start(ArgPtr);
Format = va_arg(ArgPtr, char *);
#else
static void IFprintf(int Indent, char *Format, ...)
{
char Line[LINE_LEN_LONG];
int i;
va_list ArgPtr;
va_start(ArgPtr, Format);
#endif /* USE_VARARGS */
for (i = 0; i < Indent; i++) Line[i] = ' ';
vsprintf(&Line[Indent], Format, ArgPtr);
va_end(ArgPtr);
if (OutputFile != NULL)
fputs(Line, OutputFile);
else
WndwInputWindowPutStr(Line);
}
/*****************************************************************************
* Routine to print the data from given geometry object. *
*****************************************************************************/
static void DataPrsrPutAllObjects(ObjectStruct *PObj, int Indent)
{
int i;
char
*ErrStr = NULL;
CagdRType *Coords;
PolygonStruct *PPolygon;
VertexStruct *PVertex;
if (IS_GEOM_OBJ(PObj)) {
AttributeStruct
*Attr = &(PObj -> U.Attr);
IFprintf(Indent, "[OBJECT [COLOR %d]", GetObjectColor(PObj));
if (Attr -> NumStrAttribs > 0) {
IFprintf(0, "\n");
for (i = 0; i < Attr -> NumStrAttribs; i++)
IFprintf(Indent + 8,
i == Attr -> NumStrAttribs - 1 ? "[%s %s]" : "[%s %s]\n",
Attr -> StrAttrName[i], Attr -> StrAttrData[i]);
IFprintf(0, " %s\n",
strlen(PObj -> Name) ? PObj -> Name : "NONE");
}
else
IFprintf(0, " %s\n",
strlen(PObj -> Name) ? PObj -> Name : "NONE");
}
else
IFprintf(Indent, "[OBJECT %s\n",
strlen(PObj -> Name) ? PObj -> Name : "NONE");
Indent += 4;
switch (PObj -> ObjType) {
case POLY_OBJ:
for (PPolygon = PObj -> U.Pl.P;
PPolygon != NULL;
PPolygon = PPolygon -> Pnext) {
if (PPolygon -> V == NULL)
FatalError("Dump: Attemp to dump empty polygon, exit\n");
for (PVertex = PPolygon -> V -> Pnext, i = 1;
PVertex != PPolygon -> V && PVertex != NULL;
PVertex = PVertex -> Pnext, i++);
if (IS_POLYLINE_OBJ(PObj))
IFprintf(Indent, "[POLYLINE %d\n", i);
else
IFprintf(Indent, "[POLYGON [PLANE %s %s %s %s] %d\n",
Real2Str(PPolygon -> Plane[0]),
Real2Str(PPolygon -> Plane[1]),
Real2Str(PPolygon -> Plane[2]),
Real2Str(PPolygon -> Plane[3]), i);
PVertex = PPolygon -> V;
do { /* Assume at least one edge in polygon! */
if (IS_POLYLINE_OBJ(PObj))
IFprintf(Indent + 4, "[%s%s %s %s]\n",
IS_INTERNAL_EDGE(PVertex) ? "[INTERNAL] " : "",
Real2Str(PVertex -> Pt[0]),
Real2Str(PVertex -> Pt[1]),
Real2Str(PVertex -> Pt[2]));
else
IFprintf(Indent + 4, "[%s[NORMAL %s %s %s] %s %s %s]\n",
IS_INTERNAL_EDGE(PVertex) ? "[INTERNAL] " : "",
Real2Str(PVertex -> Normal[0]),
Real2Str(PVertex -> Normal[1]),
Real2Str(PVertex -> Normal[2]),
Real2Str(PVertex -> Pt[0]),
Real2Str(PVertex -> Pt[1]),
Real2Str(PVertex -> Pt[2]));
PVertex = PVertex -> Pnext;
}
while (PVertex != PPolygon -> V && PVertex != NULL);
IFprintf(Indent, "]\n"); /* Close the polygon. */
}
break;
case NUMERIC_OBJ:
IFprintf(Indent, "[NUMBER %s]\n", Real2Str(PObj -> U.R));
break;
case VECTOR_OBJ:
IFprintf(Indent, "[VECTOR %s %s %s]\n",
Real2Str(PObj -> U.Vec[0]),
Real2Str(PObj -> U.Vec[1]),
Real2Str(PObj -> U.Vec[2]));
break;
case CTLPT_OBJ:
Coords = PObj -> U.CtlPt.Coords;
switch (PObj -> U.CtlPt.PtType) {
case CAGD_PT_E2_TYPE:
IFprintf(Indent, "[CTLPT %s %s %s]\n", "E2",
Real2Str(Coords[1]),
Real2Str(Coords[2]));
break;
case CAGD_PT_P2_TYPE:
IFprintf(Indent, "[CTLPT %s %s %s %s]\n", "P2",
Real2Str(Coords[0]),
Real2Str(Coords[1]),
Real2Str(Coords[2]));
break;
case CAGD_PT_E3_TYPE:
IFprintf(Indent, "[CTLPT %s %s %s %s]\n", "E3",
Real2Str(Coords[1]),
Real2Str(Coords[2]),
Real2Str(Coords[3]));
break;
case CAGD_PT_P3_TYPE:
IFprintf(Indent, "[CTLPT %s %s %s %s %s]\n", "P3",
Real2Str(Coords[0]),
Real2Str(Coords[1]),
Real2Str(Coords[2]),
Real2Str(Coords[3]));
break;
default:
WndwInputWindowPutStr("Dump: Undefined point type");
break;
}
break;
case MATRIX_OBJ:
IFprintf(Indent, "[MATRIX\n");
for (i = 0; i < 4; i++)
IFprintf(Indent + 8, "%s %s %s %s%s\n",
Real2Str(PObj -> U.Mat[i][0]),
Real2Str(PObj -> U.Mat[i][1]),
Real2Str(PObj -> U.Mat[i][2]),
Real2Str(PObj -> U.Mat[i][3]),
i == 3 ? "]" : "");
break;
case STRING_OBJ:
IFprintf(Indent, "[STRING \"%s\"]\n", PObj -> U.Str);
break;
case OBJ_LIST_OBJ:
for (i = 0; PObj -> U.PObjList[i] != NULL; i++)
DataPrsrPutAllObjects(PObj -> U.PObjList[i], Indent);
break;
case CURVE_OBJ:
CagdCrvWriteToFile2(PObj -> U.Crv.Crv, OutputFile, Indent, NULL, &ErrStr);
break;
case SURFACE_OBJ:
CagdSrfWriteToFile2(PObj -> U.Srf.Srf, OutputFile, Indent, NULL, &ErrStr);
break;
default:
WndwInputWindowPutStr(
"Dump: Attemp to dump undefine object type.");
break;
}
Indent -= 4;
IFprintf(Indent, "]\n"); /* Close the object. */
if (ErrStr != NULL) ParserError(DP_ERR_CAGD_LIB_ERR, ErrStr);
}
/*****************************************************************************
* Convert a real number into a string. *
* The routine maintains 6 different buffers simultanuously so up to 6 calls *
* can be issued from same printf... *
*****************************************************************************/
static char *Real2Str(RealType R)
{
static int j, k,
i = 0;
static char Buffer[6][LINE_LEN_SHORT], Line[LINE_LEN];
if (ABS(R) < EPSILON) R = 0.0; /* Round off very small numbers. */
# ifdef DOUBLE
sprintf(Buffer[i], "%-8.6lg", R);
# else
sprintf(Buffer[i], "%-8.6g", R);
# endif /* DOUBLE */
for (k = 0; !isdigit(Buffer[i][k]) && k < LINE_LEN; k++);
if (k >= LINE_LEN) {
sprintf(Line, "Conversion of real number (%f) failed.\n", R);
FatalError(Line);
}
for (j = strlen(Buffer[i]) - 1; Buffer[i][j] == ' ' && j > k; j--);
if (strchr(Buffer[i], '.') != NULL)
for (; Buffer[i][j] == '0' && j > k; j--);
Buffer[i][j+1] = 0;
j = i;
i = (i + 1) % 6;
return Buffer[j];
}
/*****************************************************************************
* Routine to read the geometry data from a given file. Reads "[OBJECT ..." *
* prefixes only and invoke the auxiliary routine. *
* Note objects may be recursively defined. *
*****************************************************************************/
static void DataPrsrGetAllObjects(FILE *f, ObjectStruct *PObjParent)
{
char StringToken[LINE_LEN];
TokenType Token;
int ObjCount = 0,
Quit = FALSE;
ObjectStruct *PObj, *OldPObj;
while (!Quit) {
while ((Token = GetToken(f, StringToken)) != TOKEN_OPEN_PAREN &&
Token != TOKEN_CLOSE_PAREN &&
Token != TOKEN_EOF);
if (Token == TOKEN_CLOSE_PAREN || Token == TOKEN_EOF)
{
if (Token == TOKEN_CLOSE_PAREN)
UnGetToken(StringToken);
Quit = TRUE;
break;
}
switch (GetToken(f, StringToken)) {
case TOKEN_OBJECT:
PObjParent -> ObjType = OBJ_LIST_OBJ;
PObj = AllocObject("", UNDEF_OBJ, NULL);
/* The following handle optional attributes in record. */
if (GetToken(f, StringToken) == TOKEN_OPEN_PAREN)
GetObjectAttributes(PObj, f);
else
{
SetObjectColor(PObj, GlblLoadColor);
UnGetToken(StringToken);
}
if (GetToken(f, StringToken) == TOKEN_OTHER &&
strcmp(StringToken, "NONE") != 0)
strcpy(PObj -> Name, StringToken);
DataPrsrGetAllObjects(f, PObj);
GetCloseParenToken(f);
if (PObj -> ObjType == UNDEF_OBJ)
ParserError(DP_ERR_OBJECT_EMPTY, "");
PObjParent -> U.PObjList[ObjCount++] = PObj;
if ((int) strlen(PObj -> Name) > 0) {
if ((OldPObj = GetObject(PObj -> Name)) != NULL)
DeleteObject(OldPObj, TRUE);
InsertObject(PObj);
PObj -> Count++;
}
break;
default:
UnGetToken(StringToken);
UnGetToken("[");
DataPrsrGetAuxObject(f, PObjParent);
Quit = TRUE;
break;
}
}
if (PObjParent -> ObjType == UNDEF_OBJ)
ParserError(DP_ERR_OBJECT_EMPTY, "");
else if (PObjParent -> ObjType == OBJ_LIST_OBJ)
PObjParent -> U.PObjList[ObjCount++] = NULL;
}
/*****************************************************************************
* Routine to get close paren token from f. *
*****************************************************************************/
static void GetCloseParenToken(FILE *f)
{
char StringToken[LINE_LEN];
if (GetToken(f, StringToken) != TOKEN_CLOSE_PAREN)
ParserError(DP_ERR_CLOSE_PAREN_EXPECTED, StringToken);
}
/*****************************************************************************
* Routine to get one numeric token into r. *
*****************************************************************************/
static void GetNumericToken(FILE *f, RealType *r)
{
char StringToken[LINE_LEN];
GetToken(f, StringToken);
# ifdef DOUBLE
if (sscanf(StringToken, "%lf", r) != 1)
# else
if (sscanf(StringToken, "%f", r) != 1)
# endif /* DOUBLE */
ParserError(DP_ERR_NUMBER_EXPECTED, StringToken);
}
/*****************************************************************************
* Routine to read the geometry data from a given file. *
*****************************************************************************/
static void DataPrsrGetAuxObject(FILE *f, ObjectStruct *PObj)
{
int i, j, ErrLine, HasPlane, HasNormal;
char *p1, *p2, *ErrStr, StringToken[LINE_LEN];
CagdRType *Coords;
VertexStruct *PVertex;
PolygonStruct *PPolygon;
CagdCrvStruct *PCurve;
CagdSrfStruct *PSurface;
while (GetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
switch (GetToken(f, StringToken)) {
case TOKEN_POLYLINE:
switch (PObj -> ObjType) {
case POLY_OBJ:
if (!IS_POLYLINE_OBJ(PObj))
ParserError(DP_ERR_MIXED_TYPES, "");
break;
case UNDEF_OBJ:
PObj -> ObjType = POLY_OBJ;
PObj -> U.Pl.P = NULL;
SET_POLYLINE_OBJ(PObj);
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
PPolygon = AllocPolygon(0, 0, NULL, NULL);
/* The following handle the optional attributes in struct. */
if (GetToken(f, StringToken) == TOKEN_OPEN_PAREN)
GetPolygonAttributes(PPolygon, f, &HasPlane);
else
UnGetToken(StringToken);
/* The following handles reading the vertices. */
GetPointData(f, PPolygon, TRUE, &HasNormal);
PPolygon -> Pnext = PObj -> U.Pl.P;
PObj -> U.Pl.P = PPolygon;
break;
case TOKEN_POLYGON:
switch (PObj -> ObjType) {
case POLY_OBJ:
if (IS_POLYLINE_OBJ(PObj))
ParserError(DP_ERR_MIXED_TYPES, "");
break;
case UNDEF_OBJ:
PObj -> ObjType = POLY_OBJ;
PObj -> U.Pl.P = NULL;
RST_POLYLINE_OBJ(PObj);
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
PPolygon = AllocPolygon(0, 0, NULL, NULL);
/* The following handle the optional attributes in struct. */
HasPlane = HasNormal = FALSE;
if (GetToken(f, StringToken) == TOKEN_OPEN_PAREN)
GetPolygonAttributes(PPolygon, f, &HasPlane);
else
UnGetToken(StringToken);
/* The following handles reading the vertices. */
GetPointData(f, PPolygon, FALSE, &HasNormal);
if (!HasPlane) DPUpdatePolyPlane(PPolygon);
if (!HasNormal) {
/* Update all normals to be the same as plane eqn. */
PVertex = PPolygon -> V;
do {
PT_COPY(PVertex -> Normal, PPolygon -> Plane);
PVertex = PVertex -> Pnext;
}
while (PVertex != PPolygon -> V && PVertex != NULL);
}
PPolygon -> Pnext = PObj -> U.Pl.P;
PObj -> U.Pl.P = PPolygon;
break;
case TOKEN_NUMBER:
switch (PObj -> ObjType) {
case NUMERIC_OBJ:
break;
case UNDEF_OBJ:
PObj -> ObjType = NUMERIC_OBJ;
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
GetNumericToken(f, &PObj -> U.R);
GetCloseParenToken(f);
break;
case TOKEN_STRING:
switch (PObj -> ObjType) {
case STRING_OBJ:
break;
case UNDEF_OBJ:
PObj -> ObjType = STRING_OBJ;
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
GetToken(f, StringToken);
if ((p1 = strchr(StringToken, '"')) == NULL ||
(p2 = strrchr(StringToken, '"')) == p1)
ParserError(DP_STR_NOT_IN_QUOTES, StringToken);
/* Convert the end quote to EOS and copy string. */
*p2 = 0;
strcpy(PObj -> U.Str, &p1[1]);
GetCloseParenToken(f);
break;
case TOKEN_VECTOR:
switch (PObj -> ObjType) {
case VECTOR_OBJ:
break;
case UNDEF_OBJ:
PObj -> ObjType = VECTOR_OBJ;
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
for (i = 0; i < 3; i++)
GetNumericToken(f, &PObj -> U.Vec[i]);
GetCloseParenToken(f);
break;
case TOKEN_MATRIX:
switch (PObj -> ObjType) {
case MATRIX_OBJ:
break;
case UNDEF_OBJ:
PObj -> ObjType = MATRIX_OBJ;
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
GetNumericToken(f, &PObj -> U.Mat[i][j]);
GetCloseParenToken(f);
break;
case TOKEN_CTLPT:
switch (PObj -> ObjType) {
case CTLPT_OBJ:
break;
case UNDEF_OBJ:
PObj -> ObjType = CTLPT_OBJ;
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
switch (GetToken(f, StringToken)) {
case TOKEN_E2:
PObj -> U.CtlPt.PtType = CAGD_PT_E2_TYPE;
j = 2;
i = 1;
break;
case TOKEN_P2:
PObj -> U.CtlPt.PtType = CAGD_PT_P2_TYPE;
j = 3;
i = 0;
break;
case TOKEN_E3:
PObj -> U.CtlPt.PtType = CAGD_PT_E3_TYPE;
j = 3;
i = 1;
break;
case TOKEN_P3:
PObj -> U.CtlPt.PtType = CAGD_PT_P3_TYPE;
j = 4;
i = 0;
break;
default:
WndwInputWindowPutStr("Read: Undefined point type");
break;
}
Coords = PObj -> U.CtlPt.Coords;
for ( ; j > 0; i++, j--)
GetNumericToken(f, &Coords[i]);
GetCloseParenToken(f);
break;
case TOKEN_SURFACE:
switch (PObj -> ObjType) {
case SURFACE_OBJ:
break;
case UNDEF_OBJ:
PObj -> ObjType = SURFACE_OBJ;
PObj -> U.Srf.Srf = NULL;
PObj -> U.Srf.PLPolys = NULL;
PObj -> U.Srf.CtlMesh = NULL;
PObj -> U.Srf.Polygons = NULL;
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
ErrLine = GlblLineCount;
PSurface = CagdSrfReadFromFile2(f, &ErrStr, &ErrLine);
GlblLineCount = ErrLine;
if (ErrStr != NULL) {
ParserError(DP_ERR_CAGD_LIB_ERR, ErrStr);
break;
}
PSurface -> Pnext = PObj -> U.Srf.Srf;
PObj -> U.Srf.Srf = PSurface;
break;
case TOKEN_CURVE:
switch (PObj -> ObjType) {
case CURVE_OBJ:
break;
case UNDEF_OBJ:
PObj -> ObjType = CURVE_OBJ;
PObj -> U.Crv.Crv = NULL;
PObj -> U.Crv.PLPolys = NULL;
PObj -> U.Crv.CtlPoly = NULL;
break;
default:
ParserError(DP_ERR_MIXED_TYPES, "");
break;
}
ErrLine = GlblLineCount;
PCurve = CagdCrvReadFromFile2(f, &ErrStr, &ErrLine);
GlblLineCount = ErrLine;
if (ErrStr != NULL) {
ParserError(DP_ERR_CAGD_LIB_ERR, ErrStr);
break;
}
PCurve -> Pnext = PObj -> U.Crv.Crv;
PObj -> U.Crv.Crv = PCurve;
break;
default:
ParserError(DP_ERR_UNDEF_EXPR_HEADER, StringToken);
break;
} /* Of switch. */
} /* Of while. */
UnGetToken(StringToken);
}
/*****************************************************************************
* Routine to unget one token (on stack of UNGET_STACK_SIZE levels!) *
*****************************************************************************/
static void UnGetToken(char *StringToken)
{
if (GlblToken >= UNGET_STACK_SIZE)
FatalError("Parser Internal stack overflow...\n");
strcpy(GlblStringToken[GlblToken], StringToken);
GlblToken++; /* GlblToken exists - Something in it (no overflow check). */
}
/*****************************************************************************
* Routine to get the next token out of the input file f. *
* Returns the next token found, as StringToken. *
* Note: StringToken must be allocated before calling this routine! *
*****************************************************************************/
static void GetStringToken(FILE *f, char *StringToken)
{
int len;
char c, *LocalStringToken;
if (GlblToken) { /* get first the unget token */
GlblToken--;
strcpy(StringToken, GlblStringToken[GlblToken]);
return;
}
/* skip white spaces: */
while ((!feof(f))
&& (((c = getc(f)) == ' ') || (c == '\t') || (c == '\n')))
if (c == '\n') GlblLineCount++; /* Count the lines. */
LocalStringToken = StringToken;
if (c == '[') /* Its a token by itself so return it. */
*LocalStringToken++ = c; /* Copy the token into string. */
else {
if (!feof(f))
do *LocalStringToken++ = c; /* Copy the token into string. */
while ((!feof(f)) &&
((c = getc(f)) != ' ') && (c != '\t') && (c != '\n'));
if (c == '\n') ungetc(c, f); /* Save it to be counted next time. */
}
*LocalStringToken = 0; /* Put eos. */
/* The following handles the spacial case were we have XXXX] - we must */
/* split it into two token XXXX and ], UnGetToken(']') and return XXXX: */
if ((StringToken[len = strlen(StringToken)-1] == ']') && (len > 0)) {
/* Return CloseParan */
UnGetToken(&StringToken[len]); /* Save next token. */
StringToken[len] = 0; /* Set end of string on "]". */
}
}
/*****************************************************************************
* Routine to get the next token out of the input file f as token number. *
* Note: StringToken must be allocated before calling this routine! *
*****************************************************************************/
static TokenType GetToken(FILE *f, char *StringToken)
{
static int IntTokens[] = {
TOKEN_OPEN_PAREN,
TOKEN_CLOSE_PAREN,
TOKEN_VERTEX,
TOKEN_POLYGON,
TOKEN_POLYLINE,
TOKEN_OBJECT,
TOKEN_COLOR,
TOKEN_INTERNAL,
TOKEN_NORMAL,
TOKEN_PLANE,
TOKEN_CURVE,
TOKEN_SURFACE,
TOKEN_E2,
TOKEN_P2,
TOKEN_E3,
TOKEN_P3,
TOKEN_NUMBER,
TOKEN_STRING,
TOKEN_VECTOR,
TOKEN_MATRIX,
TOKEN_CTLPT,
0
};
static char *StrTokens[] = {
"[",
"]",
"VERTEX",
"POLYGON",
"POLYLINE",
"OBJECT",
"COLOR",
"INTERNAL",
"NORMAL",
"PLANE",
"CURVE",
"SURFACE",
"E2",
"P2",
"E3",
"P3",
"NUMBER",
"STRING",
"VECTOR",
"MATRIX",
"CTLPT",
NULL
};
int i;
GetStringToken(f, StringToken);
if (feof(f)) return TOKEN_EOF;
for (i = 0; StrTokens[i] != NULL; i++)
if (strcmp(StringToken, StrTokens[i]) == 0) return IntTokens[i];
return TOKEN_OTHER; /* Must be number or name. */
}
/*****************************************************************************
* Routine to read from input file f the following [ATTR ...] [ATTR ...]. *
* Note the '[' was allready read. *
* Current supported attributes: [INTERNAL] - internal edge (IRIT output). *
*****************************************************************************/
static void GetVertexAttributes(VertexStruct *PVertex, FILE *f,
int *HasNormal)
{
int i;
char StringToken[LINE_LEN];
do {
switch (GetToken(f, StringToken)) {
case TOKEN_INTERNAL:
if (GetToken(f, StringToken) != TOKEN_CLOSE_PAREN)
ParserError(DP_ERR_CLOSE_PAREN_EXPECTED, StringToken);
SET_INTERNAL_EDGE(PVertex);
break;
case TOKEN_NORMAL:
/* The following handles reading 3 coord. of vertex normal. */
for (i = 0; i < 3; i++)
GetNumericToken(f, &PVertex -> Normal[i]);
GetCloseParenToken(f);
*HasNormal = TRUE;
break;
default: /* Ignore this option! */
while (GetToken(f, StringToken) != TOKEN_CLOSE_PAREN);
break;
}
}
while (GetToken(f, StringToken) == TOKEN_OPEN_PAREN);
UnGetToken(StringToken);
}
/*****************************************************************************
* Routine to read from input file f the following [ATTR ...] [ATTR ...]. *
* Note the '[' was allready read. *
* Current supported attributes: [PLANE A B C D]. *
*****************************************************************************/
static void GetPolygonAttributes(PolygonStruct *PPolygon, FILE *f,
int *HasPlane)
{
int i;
char StringToken[LINE_LEN];
do {
switch (GetToken(f, StringToken)) {
case TOKEN_PLANE:
/* The following handles reading of 4 coord. of plane eqn.. */
for (i = 0; i < 4; i++)
GetNumericToken(f, &PPolygon -> Plane[i]);
GetCloseParenToken(f);
*HasPlane = TRUE;
break;
default:
while (GetToken(f, StringToken) != TOKEN_CLOSE_PAREN);
break;
}
}
while (GetToken(f, StringToken) == TOKEN_OPEN_PAREN);
UnGetToken(StringToken);
}
/*****************************************************************************
* Routine to read from input file f the following [ATTR ...] [ATTR ...]. *
* Note the '[' was allready read. *
* Current supported attributes: [COLOR C] - set color. *
* All other attributes are treated as String attributes. *
*****************************************************************************/
static void GetObjectAttributes(ObjectStruct *PObject, FILE *f)
{
int i;
char StringToken[LINE_LEN], Data[LINE_LEN], Name[LINE_LEN];
do {
switch (GetToken(f, StringToken)) {
case TOKEN_COLOR:
GetToken(f, StringToken);
if (sscanf(StringToken, "%d", &i) != 1)
ParserError(DP_ERR_NUMBER_EXPECTED, StringToken);
GetCloseParenToken(f);
SetObjectColor(PObject, i);
break;
default:
strcpy(Name, StringToken);
strcpy(Data, " ");
while (GetToken(f, StringToken) != TOKEN_CLOSE_PAREN) {
strcat(Data, StringToken);
strcat(Data, " ");
}
SetObjectStrAttrib(PObject, Name, Data);
break;
}
}
while (GetToken(f, StringToken) == TOKEN_OPEN_PAREN);
UnGetToken(StringToken);
}
/*****************************************************************************
* Routine to read poly* vertex information. *
*****************************************************************************/
static void GetPointData(FILE *f, PolygonStruct *PPolygon, int IsPolyline,
int *HasNormal)
{
int i, j, Length;
char StringToken[LINE_LEN];
VertexStruct *V,
*VTail = NULL;
if (GetToken(f, StringToken) != TOKEN_OTHER ||
sscanf(StringToken, "%d", &Length) != 1)
ParserError(DP_ERR_NUMBER_EXPECTED, StringToken);
for (i = 0; i < Length; i++) {
if (GetToken(f, StringToken) != TOKEN_OPEN_PAREN)
ParserError(DP_ERR_OPEN_PAREN_EXPECTED, StringToken);
V = AllocVertex(0, 0, NULL, NULL);
/* The following handle the optional attributes in struct. */
*HasNormal = FALSE;
if (GetToken(f, StringToken) == TOKEN_OPEN_PAREN)
GetVertexAttributes(V, f, HasNormal);
else
UnGetToken(StringToken);
for (j = 0; j < 3; j++) /* Read coordinates. */
GetNumericToken(f, &V -> Pt[j]);
GetCloseParenToken(f);
if (!*HasNormal)
PT_COPY(V -> Normal, PPolygon -> Plane);
if (VTail == NULL)
PPolygon -> V = VTail = V;
else {
VTail -> Pnext = V;
VTail = V;
}
}
VTail -> Pnext = IsPolyline ? NULL : PPolygon -> V;
GetCloseParenToken(f);
}
/*****************************************************************************
* Routine to update the Plane equation of the given polygon by the order *
* of the first 3 vertices of that polygon. *
*****************************************************************************/
static void DPUpdatePolyPlane(PolygonStruct *PPoly)
{
int i;
VectorType V1, V2;
RealType Len;
VertexStruct *V;
V = PPoly -> V; PT_SUB(V1, V -> Pt, V -> Pnext -> Pt);
V = V -> Pnext; PT_SUB(V2, V -> Pt, V -> Pnext -> Pt);
PPoly -> Plane[0] = V1[1] * V2[2] - V2[1] * V1[2];
PPoly -> Plane[1] = V1[2] * V2[0] - V2[2] * V1[0];
PPoly -> Plane[2] = V1[0] * V2[1] - V2[0] * V1[1];
PPoly -> Plane[3] = (-DOT_PROD(PPoly -> Plane, PPoly -> V -> Pt));
/* Normalize the plane such that the normal has length of 1: */
Len = PT_LENGTH(PPoly -> Plane);
for (i = 0; i < 4; i++) PPoly -> Plane[i] /= Len;
}
/*****************************************************************************
* Routine to print pasring error according to ErrNum and set GlblParserError.*
*****************************************************************************/
static void ParserError(DataPrsrErrType ErrNum, char *Msg)
{
DPGlblLineCount = GlblLineCount;
DPGlblParserError = ErrNum;
strcpy(DPGlblTokenError, Msg); /* Keep the message in safe place... */
longjmp(LclLongJumpBuffer, 1); /* Jump to... */
}
/*****************************************************************************
* Returns TRUE if error happened, FALSE otherwise. *
* If error, then ErrorMsg is updated to point on static str describing it. *
*****************************************************************************/
int DataPrsrParseError(char **ErrorMsg)
{
DataPrsrErrType Temp;
char TempCopy[LINE_LEN];
if ((Temp = DPGlblParserError) == DP_NO_ERR) return FALSE;
strcpy(TempCopy, DPGlblTokenError);
DPGlblParserError = DP_NO_ERR;
switch (Temp) {
case DP_ERR_NUMBER_EXPECTED:
sprintf(DPGlblTokenError, "Line %d: Numeric data expected - found %s",
DPGlblLineCount, TempCopy);
break;
case DP_ERR_OPEN_PAREN_EXPECTED:
sprintf(DPGlblTokenError, "Line %d: '[' expected - found '%s'",
DPGlblLineCount, TempCopy);
break;
case DP_ERR_CLOSE_PAREN_EXPECTED:
sprintf(DPGlblTokenError, "Line %d: ']' expected - found '%s'",
DPGlblLineCount, TempCopy);
break;
case DP_ERR_LIST_COMP_UNDEF:
sprintf(DPGlblTokenError, "Line %d: Undefined list element - \"%s\"",
DPGlblLineCount, TempCopy);
break;
case DP_ERR_UNDEF_EXPR_HEADER:
sprintf(DPGlblTokenError, "Line %d: Undefined TOKEN - \"%s\"",
DPGlblLineCount, TempCopy);
break;
case DP_ERR_PT_TYPE_EXPECTED:
sprintf(DPGlblTokenError, "Line %d: Point type expected",
DPGlblLineCount);
break;
case DP_ERR_OBJECT_EMPTY:
sprintf(DPGlblTokenError, "Line %d: Empty object found",
DPGlblLineCount);
break;
case DP_ERR_EMPTY_NAME:
sprintf(DPGlblTokenError, "Given file name is empty");
break;
case DP_ERR_OPEN_FAILED:
sprintf(DPGlblTokenError, "Fail to open file - %s", TempCopy);
break;
case DP_ERR_MIXED_TYPES:
sprintf(DPGlblTokenError,
"Line %d: Mixed data types in same object",
DPGlblLineCount);
break;
case DP_STR_NOT_IN_QUOTES:
sprintf(DPGlblTokenError,
"Line %d: String not in quotes (%s)",
DPGlblLineCount, TempCopy);
break;
case DP_ERR_CAGD_LIB_ERR:
sprintf(DPGlblTokenError, "Line %d: %s",
DPGlblLineCount, TempCopy);
break;
default:
sprintf(DPGlblTokenError,
"Line %d: Data file parser - undefined error",
DPGlblLineCount);
break;
}
*ErrorMsg = DPGlblTokenError;
return TRUE;
}
