home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / PARSE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  120.6 KB  |  3,994 lines
  1. /****************************************************************************
  2. *                parse.c
  3. *
  4. *  This module implements a parser for the scene description files.
  5. *
  6. *  from Persistence of Vision Raytracer 
  7. *  Copyright 1992 Persistence of Vision Team
  8. *---------------------------------------------------------------------------
  9. *  Copying, distribution and legal info is in the file povlegal.doc which
  10. *  should be distributed with this file. If povlegal.doc is not available
  11. *  or for more info please contact:
  12. *
  13. *       Drew Wells [POV-Team Leader] 
  14. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  15. *       Phone: (213) 254-4041
  16. * 
  17. * This program is based on the popular DKB raytracer version 2.12.
  18. * DKBTrace was originally written by David K. Buck.
  19. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  20. *
  21. *****************************************************************************/
  22.  
  23.  
  24. #include "frame.h"
  25. #include "vector.h"
  26. #include "povproto.h"
  27.  
  28.  
  29.  
  30. /* This file implements a simple recursive-descent parser for reading the
  31. input file.  */
  32.  
  33. static void Link_Shapes PARAMS((LIGHT_SHAPE *New_Object,LIGHT_SHAPE **Field,LIGHT_SHAPE **Old_Object_List));
  34. static void Post_Process_Object PARAMS((OBJECT *Object));
  35. static void Post_Process_Shape PARAMS((SHAPE *Shape));
  36.  
  37.  
  38.  
  39. extern DBL Max_Trace_Level;
  40. extern char VerboseFormat;
  41. extern unsigned int Options;
  42. extern char Stat_File_Name[FILE_NAME_LENGTH];
  43.  
  44.  
  45. FRAME *Parsing_Frame_Ptr;
  46.  
  47. extern METHODS Composite_Methods;
  48. extern METHODS Basic_Object_Methods;
  49. extern METHODS Sphere_Methods;
  50. extern METHODS Point_Methods;
  51. extern METHODS Quadric_Methods;
  52. extern METHODS Poly_Methods;
  53. extern METHODS Box_Methods;
  54. extern METHODS Blob_Methods;
  55. extern METHODS Bicubic_Patch_Methods;
  56. extern METHODS Viewpoint_Methods;
  57. extern METHODS Plane_Methods;
  58. extern METHODS Triangle_Methods;
  59. extern METHODS Smooth_Triangle_Methods;
  60. extern METHODS CSG_Union_Methods;
  61. extern METHODS CSG_Intersection_Methods;
  62. extern METHODS Height_Field_Methods;
  63.  
  64. extern struct Reserved_Word_Struct Reserved_Words [];
  65. extern DBL Antialias_Threshold;
  66.  
  67. extern int term_counts[MAX_ORDER+1];
  68. extern struct Token_Struct Token;
  69.  
  70. COLOUR_MAP_ENTRY *Construction_Map = NULL; /* moved here to allow reinitialization */
  71.  
  72. struct Constant_Struct Constants[MAX_CONSTANTS];
  73. int Number_Of_Constants;
  74. TEXTURE *Default_Texture;
  75. int Degenerate_Triangles;
  76.  
  77. /* Here we create our own little language for doing the parsing.  It
  78. makes the code easier to read. */
  79.  
  80. #define EXPECT { int Exit_Flag; Exit_Flag = FALSE; \
  81. while (!Exit_Flag) {Get_Token();  switch (Token.Token_Id) {
  82. #define CASE(x) case x:
  83. #define CASE2(x, y) case x: case y:
  84. #define CASE3(x, y, z) case x: case y: case z:
  85. #define CASE4(w, x, y, z) case w: case x: case y: case z:
  86. #define CASE5(v, w, x, y, z) case v: case w: case x: case y: case z:
  87. #define CASE6(u, v, w, x, y, z) case u: case v: case w: case x: case y: case z:
  88. #define END_CASE break;
  89. #define EXIT Exit_Flag = TRUE;
  90. #define OTHERWISE default:
  91. #define END_EXPECT } } }
  92. #define GET(x) Get_Token(); if (Token.Token_Id != x) Parse_Error (x)
  93. #define UNGET Unget_Token();
  94.  
  95.       /*
  96.  
  97. char *Coeff_terms[35] = {
  98.    "x^4", "x^3*y", "x^3*z", "x^3", "x^2*y^2", "x^2*y*z", "x^2*y", "x^2*z^2",
  99.    "x^2*z", "x^2", "x*y^3", "x*y^2*z", "x*y^2", "x*y*z^2", "x*y*z", "x*y",
  100.    "x*z^3", "x*z^2", "x*z", "x", "y^4", "y^3*z", "y^3", "y^2*z^2", "y^2*z",
  101.    "y^2", "y*z^3", "y*z^2", "y*z", "y", "z^4", "z^3", "z^2", "z", ""
  102.    };
  103.  
  104. void show_quartic(Coeffs)
  105. DBL *Coeffs;
  106. {
  107.    int i,j;
  108.    for (i=0,j=0;i<35;i++)
  109.       if (Coeffs[i] != 0.0) {
  110.      if (j) printf(" + ");
  111.      printf("%.5Lg %s", Coeffs[i], Coeff_terms[i]);
  112.      j = 1;
  113.      }
  114. }
  115.  
  116. */
  117.  
  118.       /* Parse the file into the given frame. */
  119.       void Parse (Frame_Ptr)
  120.          FRAME *Frame_Ptr;
  121.       {
  122.          OBJECT *Object;
  123.          Parsing_Frame_Ptr = Frame_Ptr;
  124.  
  125.          Degenerate_Triangles = FALSE;
  126.          Token_Init ();
  127.          Frame_Init ();
  128.          Parse_Frame ();
  129.          for (Object = Parsing_Frame_Ptr->Objects;
  130.                 Object != NULL;
  131.                 Object = Object->Next_Object)
  132.             Post_Process_Object (Object);
  133.          if (Degenerate_Triangles) {
  134.             fprintf (stderr, "Degenerate triangles were found and are being ignored.\n");
  135.             /* exit(1); Let's ignore degen tri instead of blowing up. CdW */
  136.          }
  137.       }
  138.  
  139.       void Token_Init ()
  140.       {
  141.          Number_Of_Constants = 0;
  142.          /*
  143.   Constants = (struct Constant_Struct *)malloc(
  144.       sizeof(struct Constant_Struct) *MAX_CONSTANTS);
  145.   */
  146.       }
  147.  
  148.  
  149.       /* Set up the fields in the frame to default values. */
  150.       void Frame_Init ()
  151.       {
  152.          Default_Texture = Get_Texture();
  153.          Init_Viewpoint(&(Parsing_Frame_Ptr -> View_Point));
  154.          Parsing_Frame_Ptr -> Light_Sources = NULL;
  155.          Parsing_Frame_Ptr -> Objects = NULL;
  156.          Parsing_Frame_Ptr -> Atmosphere_IOR = 1.0;
  157.          Parsing_Frame_Ptr -> Antialias_Threshold = Antialias_Threshold;
  158.          Parsing_Frame_Ptr -> Fog_Distance = 0.0;
  159.          Make_Colour (&(Parsing_Frame_Ptr->Fog_Colour), 0.0, 0.0, 0.0);
  160.       }
  161.  
  162.       /* Allocate and initialize a composite object. */
  163.       COMPOSITE *Get_Composite_Object()
  164.       {
  165.          COMPOSITE *New_Composite;
  166.  
  167.          if ((New_Composite = (COMPOSITE *) malloc (sizeof (COMPOSITE)))
  168.             == NULL)
  169.             Error ("Out of memory. Cannot allocate object");
  170.  
  171.          New_Composite -> Objects = NULL;
  172.          New_Composite -> Next_Object = NULL;
  173.          /*  New_Composite -> Next_Light_Source = NULL;*/
  174.          New_Composite -> Bounding_Shapes = NULL;
  175.          New_Composite -> Clipping_Shapes = NULL;
  176.          New_Composite -> Type = COMPOSITE_TYPE;
  177.          New_Composite -> Methods = &Composite_Methods;
  178.          return (New_Composite);
  179.       }
  180.  
  181.       /* Allocate and initialize a sphere. */
  182.       SPHERE *Get_Sphere_Shape()
  183.       {
  184.          SPHERE *New_Shape;
  185.  
  186.          if ((New_Shape = (SPHERE *) malloc (sizeof (SPHERE))) == NULL)
  187.             Error ("Out of memory. Cannot allocate shape");
  188.  
  189.          Make_Vector (&(New_Shape -> Center), 0.0, 0.0, 0.0);
  190.          New_Shape->Radius = 1.0;
  191.          New_Shape->Radius_Squared = 1.0;
  192.          New_Shape->Inverse_Radius = 1.0;
  193.          New_Shape -> Type = SPHERE_TYPE;
  194.          New_Shape -> Next_Object = NULL;
  195.          New_Shape -> Methods = &Sphere_Methods;
  196.          New_Shape -> VPCached = FALSE;
  197.          New_Shape -> Inverted = FALSE;
  198.          New_Shape -> Shape_Texture = NULL;
  199.          New_Shape -> Shape_Colour = NULL;
  200.          return (New_Shape);
  201.       }
  202.  
  203.       /* Allocate and initialize a light source. */
  204.       /* A point light source has no shape, but we'll treat it like it does */
  205.  
  206.       LIGHT_SHAPE *Get_Light_Source_Shape()
  207.       {
  208.          LIGHT_SHAPE *New_Shape;
  209.  
  210.          if ((New_Shape = (LIGHT_SHAPE *) malloc (sizeof (LIGHT_SHAPE))) == NULL)
  211.             Error ("Out of memory. Cannot allocate shape");
  212.          Make_Vector (&(New_Shape -> Center), 0.0, 0.0, 0.0);
  213.          Make_Vector (&(New_Shape -> Points_At), 0.0, 0.0, 1.0);
  214.          New_Shape -> Type = POINT_LIGHT_TYPE;
  215.          New_Shape -> Methods = &Point_Methods;
  216.          New_Shape -> Next_Object = NULL;
  217.          New_Shape -> Inverted = FALSE; /* needed so CSG routines don't blow up */
  218.          New_Shape -> Shape_Texture = NULL; /* always NULL */
  219.          New_Shape -> Shape_Colour = Get_Colour();  /* becomes light colour */
  220.          Make_Colour(New_Shape->Shape_Colour, 1.0, 1.0, 1.0);
  221.          New_Shape->Shape_Colour->Alpha = 0.0;
  222.          New_Shape -> Coeff   = 10.0;
  223.          New_Shape -> Radius  = 0.35;
  224.          New_Shape -> Falloff = 0.35;
  225.          return (New_Shape);
  226.       }
  227.  
  228.       /* Allocate and initialize a quadric surface. */
  229.       QUADRIC *Get_Quadric_Shape()
  230.       {
  231.          QUADRIC *New_Shape;
  232.  
  233.          if ((New_Shape = (QUADRIC *) malloc (sizeof (QUADRIC))) == NULL)
  234.             Error ("Out of memory. Cannot allocate shape");
  235.  
  236.          Make_Vector (&(New_Shape -> Object_2_Terms), 1.0, 1.0, 1.0);
  237.          Make_Vector (&(New_Shape -> Object_Mixed_Terms), 0.0, 0.0, 0.0);
  238.          Make_Vector (&(New_Shape -> Object_Terms), 0.0, 0.0, 0.0);
  239.          New_Shape -> Object_Constant = 1.0;
  240.          New_Shape -> Object_VP_Constant = HUGE_VAL;
  241.          New_Shape -> Constant_Cached = FALSE;
  242.          New_Shape -> Non_Zero_Square_Term = FALSE;
  243.          New_Shape -> Type = QUADRIC_TYPE;
  244.          New_Shape -> Next_Object = NULL;
  245.          New_Shape -> Methods = &Quadric_Methods;
  246.          New_Shape -> Shape_Texture = NULL;
  247.          New_Shape -> Shape_Colour = NULL;
  248.          return (New_Shape);
  249.       }
  250.       /* Allocate and initialize a polynomial surface. */
  251.       POLY *Get_Poly_Shape(order)
  252.          int order;
  253.       {
  254.          POLY *New_Shape;
  255.          int i;
  256.  
  257.          if ((New_Shape = (POLY *) malloc (sizeof (POLY))) == NULL)
  258.             Error ("Out of memory. Cannot allocate shape");
  259.  
  260.          New_Shape->Type = POLY_TYPE;
  261.          New_Shape->Next_Object = NULL;
  262.          New_Shape->Methods = &Poly_Methods;
  263.          New_Shape->Shape_Texture = NULL;
  264.          New_Shape->Shape_Colour = NULL;
  265.          New_Shape->Transform = NULL;
  266.          New_Shape->Inverted = 0;
  267.          New_Shape->Order = order;
  268.          New_Shape->Sturm_Flag = 0;
  269.          New_Shape->Coeffs = (DBL *)malloc(term_counts[order] * sizeof(DBL));
  270.          if (New_Shape->Coeffs == NULL)
  271.             Error("Out of memory. Cannot allocate coefficients for POLY");
  272.          for (i=0;i<term_counts[order];i++)
  273.             New_Shape->Coeffs[i] = 0.0;
  274.          return (New_Shape);
  275.       }
  276.  
  277.       /* Allocate and initialize a box. */
  278.       BOX *Get_Box_Shape()
  279.       {
  280.          BOX *New_Shape;
  281.  
  282.          if ((New_Shape = (BOX *) malloc (sizeof (BOX))) == NULL)
  283.             Error ("Out of memory. Cannot allocate shape");
  284.  
  285.          Make_Vector(&(New_Shape->bounds[0]), -1.0, -1.0, -1.0);
  286.          Make_Vector(&(New_Shape->bounds[1]),  1.0,  1.0,  1.0);
  287.          New_Shape -> Transform = NULL;
  288.          New_Shape -> Type = BOX_TYPE;
  289.          New_Shape -> Next_Object = NULL;
  290.          New_Shape -> Methods = &Box_Methods;
  291.          New_Shape -> Inverted = FALSE;
  292.          New_Shape -> Shape_Texture = NULL;
  293.          New_Shape -> Shape_Colour = NULL;
  294.          return (New_Shape);
  295.       }
  296.  
  297.       /* Allocate a blob. */
  298.       BLOB *Get_Blob_Shape()
  299.       {
  300.          BLOB *New_Shape;
  301.  
  302.          if ((New_Shape = (BLOB *) malloc (sizeof (BLOB))) == NULL)
  303.             Error ("Out of memory. Cannot allocate shape");
  304.  
  305.          New_Shape -> Transform = NULL;
  306.          New_Shape -> Type = BLOB_TYPE;
  307.          New_Shape -> Next_Object = NULL;
  308.          New_Shape -> Methods = &Blob_Methods;
  309.          New_Shape -> Inverted = FALSE;
  310.          New_Shape -> Shape_Texture = NULL;
  311.          New_Shape -> Shape_Colour = NULL;
  312.          return (New_Shape);
  313.       }
  314.  
  315.       /* Allocate and initialize a bicubic patch surface. */
  316.       BICUBIC_PATCH *Get_Bicubic_Patch_Shape()
  317.       {
  318.          BICUBIC_PATCH *New_Shape;
  319.  
  320.          if ((New_Shape = (BICUBIC_PATCH *) malloc (sizeof (BICUBIC_PATCH))) == NULL)
  321.             Error ("Out of memory. Cannot allocate shape");
  322.  
  323.          New_Shape->Type = BICUBIC_PATCH_TYPE;
  324.          New_Shape->Next_Object = NULL;
  325.          New_Shape->Methods = &Bicubic_Patch_Methods;
  326.          New_Shape->Shape_Texture = NULL;
  327.          New_Shape->Shape_Colour = NULL;
  328.          New_Shape->U_Steps = 0;
  329.          New_Shape->V_Steps = 0;
  330.          New_Shape->Intersection_Count = 0;
  331.          New_Shape->Interpolated_Grid = (VECTOR **)NULL;
  332.          New_Shape->Interpolated_Normals = (VECTOR **)NULL;
  333.          New_Shape->Smooth_Normals = (VECTOR **)NULL;
  334.          New_Shape->Interpolated_D = (DBL **)NULL;
  335.          return (New_Shape);
  336.       }       
  337.  
  338.       /* Allocate and intialize a Height Field */
  339.       HEIGHT_FIELD *Get_Height_Field_Shape()
  340.       {
  341.          HEIGHT_FIELD *New_Shape;
  342.  
  343.          if((New_Shape = (HEIGHT_FIELD *) malloc (sizeof(HEIGHT_FIELD))) == NULL)
  344.             Error ("Out of memory. Cannot allocate shape");
  345.          New_Shape -> bounding_box = Get_Box_Shape();
  346.          New_Shape -> Map = NULL;
  347.          New_Shape -> Transformation = Get_Transformation();
  348.          New_Shape -> Type = HEIGHT_FIELD_TYPE;
  349.          New_Shape -> Next_Object = NULL;
  350.          New_Shape -> Methods = &Height_Field_Methods;
  351.          New_Shape -> Shape_Texture = NULL;
  352.          New_Shape -> Shape_Colour = NULL;
  353.          return(New_Shape);
  354.       }
  355.  
  356.  
  357.       /* Allocate and initialize a plane. */
  358.       PLANE *Get_Plane_Shape()
  359.       {
  360.          PLANE *New_Shape;
  361.  
  362.          if ((New_Shape = (PLANE *) malloc (sizeof (PLANE))) == NULL)
  363.             Error ("Out of memory. Cannot allocate shape");
  364.  
  365.          Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
  366.          New_Shape->Distance = 0.0;
  367.          New_Shape -> Type = PLANE_TYPE;
  368.          New_Shape -> Next_Object = NULL;
  369.          New_Shape -> Methods = &Plane_Methods;
  370.          New_Shape -> VPCached = 0;
  371.          New_Shape -> Shape_Texture = NULL;
  372.          New_Shape -> Shape_Colour = NULL;
  373.          return (New_Shape);
  374.       }
  375.  
  376.       /* Allocate and initialize a triangle. */
  377.       TRIANGLE *Get_Triangle_Shape()
  378.       {
  379.          TRIANGLE *New_Shape;
  380.  
  381.          if ((New_Shape = (TRIANGLE *) malloc (sizeof (TRIANGLE))) == NULL)
  382.             Error ("Out of memory. Cannot allocate shape");
  383.  
  384.          Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
  385.          Make_Vector (&(New_Shape -> P1), 0.0, 0.0, 0.0);
  386.          Make_Vector (&(New_Shape -> P2), 1.0, 0.0, 0.0);
  387.          Make_Vector (&(New_Shape -> P3), 0.0, 1.0, 0.0);
  388.          New_Shape->Distance = 0.0;
  389.          New_Shape->Inverted = FALSE;
  390.          New_Shape -> Type = TRIANGLE_TYPE;
  391.          New_Shape -> Next_Object = NULL;
  392.          New_Shape -> Methods = &Triangle_Methods;
  393.          New_Shape -> VPCached = FALSE;
  394.          New_Shape -> Shape_Texture = NULL;
  395.          New_Shape -> Shape_Colour = NULL;
  396.          New_Shape -> Degenerate_Flag = FALSE;
  397.          return (New_Shape);
  398.       }
  399.  
  400.       /* Allocate and initialize a smooth triangle. */
  401.       SMOOTH_TRIANGLE *Get_Smooth_Triangle_Shape()
  402.       {
  403.          SMOOTH_TRIANGLE *New_Shape;
  404.  
  405.          if ((New_Shape = (SMOOTH_TRIANGLE *) malloc (sizeof (SMOOTH_TRIANGLE))) == NULL)
  406.             Error ("Out of memory. Cannot allocate shape");
  407.  
  408.          Make_Vector (&(New_Shape -> Normal_Vector), 0.0, 1.0, 0.0);
  409.          Make_Vector (&(New_Shape -> P1), 0.0, 0.0, 0.0);
  410.          Make_Vector (&(New_Shape -> P2), 1.0, 0.0, 0.0);
  411.          Make_Vector (&(New_Shape -> P3), 0.0, 1.0, 0.0);
  412.          Make_Vector (&(New_Shape -> N1), 0.0, 1.0, 0.0);
  413.          Make_Vector (&(New_Shape -> N2), 0.0, 1.0, 0.0);
  414.          Make_Vector (&(New_Shape -> N3), 0.0, 1.0, 0.0);
  415.          New_Shape->Distance = 0.0;
  416.          New_Shape -> Type = SMOOTH_TRIANGLE_TYPE;
  417.          New_Shape->Inverted = FALSE;
  418.          New_Shape -> Next_Object = NULL;
  419.          New_Shape -> Methods = &Smooth_Triangle_Methods;
  420.          New_Shape -> VPCached = 0;
  421.          New_Shape -> Shape_Texture = NULL;
  422.          New_Shape -> Shape_Colour = NULL;
  423.          New_Shape -> Degenerate_Flag = FALSE;
  424.          return (New_Shape);
  425.       }
  426.  
  427.       CSG_SHAPE *Get_CSG_Shape()
  428.       {
  429.          CSG_SHAPE *New_Shape;
  430.  
  431.          if ((New_Shape = (CSG_SHAPE *) malloc (sizeof (CSG_SHAPE))) == NULL)
  432.             Error ("Out of memory. Cannot allocate shape");
  433.  
  434.          New_Shape -> Parent_Object = NULL;
  435.          New_Shape -> Next_Object = NULL;
  436.          New_Shape -> Shapes = NULL;
  437.          return (New_Shape);
  438.       }
  439.  
  440.       CSG_SHAPE *Get_CSG_Union()
  441.       {
  442.          CSG_SHAPE *New_Shape;
  443.  
  444.          New_Shape = Get_CSG_Shape();
  445.          New_Shape -> Methods = &CSG_Union_Methods;
  446.          New_Shape -> Type = CSG_UNION_TYPE;
  447.          return (New_Shape);
  448.       }
  449.  
  450.       CSG_SHAPE *Get_CSG_Intersection()
  451.       {
  452.          CSG_SHAPE *New_Shape;
  453.  
  454.          New_Shape = Get_CSG_Shape();
  455.          New_Shape -> Methods = &CSG_Intersection_Methods;
  456.          New_Shape -> Type = CSG_INTERSECTION_TYPE;
  457.          return (New_Shape);
  458.       }
  459.  
  460.       OBJECT *Get_Object ()
  461.       {
  462.          OBJECT *New_Object;
  463.  
  464.          if ((New_Object = (OBJECT *) malloc (sizeof (OBJECT))) == NULL)
  465.             Error ("Out of memory. Cannot allocate object");
  466.  
  467.          New_Object -> Next_Object = NULL;
  468.          /*  New_Object -> Next_Light_Source = NULL;*/
  469.          New_Object -> Shape = NULL;
  470.          New_Object -> Bounding_Shapes = NULL;
  471.          New_Object -> Clipping_Shapes = NULL;
  472.          New_Object -> Object_Texture = Default_Texture;
  473.  
  474.          New_Object->Object_Colour = NULL;
  475.  
  476.          New_Object -> No_Shadow_Flag = FALSE;
  477.          New_Object -> Type = OBJECT_TYPE;
  478.          New_Object -> Methods = &Basic_Object_Methods;
  479.          return (New_Object);
  480.       }
  481.  
  482.       TEXTURE *Get_Texture ()
  483.       {
  484.          TEXTURE *New_Texture;
  485.  
  486.          if ((New_Texture = (TEXTURE *) malloc (sizeof (TEXTURE))) == NULL)
  487.             Error ("Out of memory. Cannot allocate object");
  488.  
  489.          New_Texture -> Next_Texture = NULL;
  490.          New_Texture -> Next_Material = NULL;
  491.          New_Texture -> Number_Of_Materials = 0;
  492.          New_Texture -> Object_Reflection = 0.0;
  493.          New_Texture -> Object_Ambient = 0.1;
  494.          New_Texture -> Object_Diffuse = 0.6;
  495.          New_Texture -> Object_Brilliance = 1.0;
  496.          New_Texture -> Object_Specular = 0.0;
  497.          New_Texture -> Object_Roughness = 0.05;
  498.          New_Texture -> Object_Phong = 0.0;
  499.          New_Texture -> Object_PhongSize = 40;
  500.  
  501.          New_Texture -> Texture_Randomness= 0.0;
  502.          New_Texture -> Bump_Amount = 0.0;
  503.          New_Texture -> Phase = 0.0;
  504.          New_Texture -> Frequency = 1.0;
  505.          New_Texture -> Texture_Number = NO_TEXTURE;
  506.          New_Texture -> Texture_Transformation = NULL;
  507.          New_Texture -> Bump_Number = NO_BUMPS;
  508.          New_Texture -> Turbulence = 0.0;
  509.          New_Texture -> Colour_Map = NULL;
  510.          New_Texture -> Once_Flag = FALSE;
  511.          New_Texture -> Metallic_Flag = FALSE;
  512.          New_Texture -> Octaves = 6;         /* dmf, for turbulence functs */
  513.          New_Texture -> Mortar = 0.2;        /* rha, for brick texture */
  514.  
  515.          New_Texture -> Constant_Flag = TRUE;
  516.          New_Texture -> Colour1 = NULL;
  517.          New_Texture -> Colour2 = NULL;
  518.          Make_Vector (&New_Texture->Texture_Gradient, 0.0, 0.0, 0.0);
  519.  
  520.          New_Texture -> Object_Index_Of_Refraction = 1.0;
  521.          New_Texture -> Object_Transmit = 0.0;
  522.          New_Texture -> Object_Refraction = 0.0;
  523.          return (New_Texture);
  524.       }
  525.  
  526.  
  527.       VIEWPOINT *Get_Viewpoint ()
  528.       {
  529.          VIEWPOINT *New_Viewpoint;
  530.  
  531.          if ((New_Viewpoint = (VIEWPOINT *)malloc (sizeof (VIEWPOINT)))
  532.             == NULL)
  533.             Error ("Out of memory. Cannot allocate viewpoint");
  534.  
  535.          Init_Viewpoint (New_Viewpoint);
  536.          return (New_Viewpoint);
  537.       }
  538.  
  539.       COLOUR *Get_Colour ()
  540.       {
  541.          COLOUR *New_Colour;
  542.  
  543.          if ((New_Colour = (COLOUR *) malloc (sizeof (COLOUR))) == NULL)
  544.             Error ("Out of memory. Cannot allocate colour");
  545.  
  546.          Make_Colour (New_Colour, 0.0, 0.0, 0.0);
  547.          return (New_Colour);
  548.       }
  549.  
  550.       VECTOR *Get_Vector ()
  551.       {
  552.          VECTOR *New_Vector;
  553.  
  554.          if ((New_Vector = (VECTOR *) malloc (sizeof (VECTOR))) == NULL)
  555.             Error ("Out of memory. Cannot allocate vector");
  556.  
  557.          New_Vector -> x = 0.0;
  558.          New_Vector -> y = 0.0;
  559.          New_Vector -> z = 0.0;
  560.          return (New_Vector);
  561.       }
  562.  
  563.       DBL *Get_Float ()
  564.       {
  565.          DBL *New_Float;
  566.  
  567.          if ((New_Float = (DBL *) malloc (sizeof (DBL))) == NULL)
  568.             Error ("Out of memory. Cannot allocate float");
  569.  
  570.          *New_Float = 0.0;
  571.          return (New_Float);
  572.       }
  573.  
  574.       TRANSFORMATION *Get_Transformation()
  575.       {
  576.          TRANSFORMATION *New_Transformation;
  577.  
  578.          if ((New_Transformation =
  579.             (TRANSFORMATION *) malloc (sizeof (TRANSFORMATION))) == NULL)
  580.             Error ("Out of memory. Cannot allocate transformation");
  581.  
  582.          MIdentity ((MATRIX *) &(New_Transformation -> matrix[0][0]));
  583.          MIdentity ((MATRIX *) &(New_Transformation -> inverse[0][0]));
  584.          return (New_Transformation);
  585.       }
  586.  
  587.       /* Parse a float.  Doesn't handle exponentiation. */
  588.       DBL Parse_Float ()
  589.       {
  590.          DBL Local_Float = 0.0;
  591.          CONSTANT Constant_Id;
  592.          register int Negative, Sign_Parsed;
  593.  
  594.          Negative = FALSE;
  595.          Sign_Parsed = FALSE;
  596.  
  597.          EXPECT
  598.          CASE (IDENTIFIER_TOKEN)
  599.             if ((Constant_Id = Find_Constant()) != -1)
  600.                if (Constants[(int)Constant_Id].Constant_Type == FLOAT_CONSTANT)
  601.                {
  602.                   Local_Float = *((DBL *) Constants[(int)Constant_Id].Constant_Data);
  603.                   if (Negative)
  604.                      Local_Float *= -1.0;
  605.                }
  606.                else
  607.                   Type_Error ();
  608.             else
  609.                Undeclared ();
  610.          EXIT
  611.          END_CASE
  612.  
  613.          CASE (PLUS_TOKEN)
  614.             if (Sign_Parsed)
  615.                Parse_Error (FLOAT_TOKEN);
  616.          Sign_Parsed = TRUE;
  617.          END_CASE
  618.  
  619.          CASE (DASH_TOKEN)
  620.             if (Sign_Parsed)
  621.                Parse_Error (FLOAT_TOKEN);
  622.          Negative = TRUE;
  623.          Sign_Parsed = TRUE;
  624.          END_CASE
  625.  
  626.          CASE (FLOAT_TOKEN)
  627.             Local_Float = Token.Token_Float;
  628.          if (Negative)
  629.             Local_Float *= -1.0;
  630.          EXIT
  631.          END_CASE
  632.  
  633.          OTHERWISE
  634.          Parse_Error (FLOAT_TOKEN);
  635.          END_CASE
  636.          END_EXPECT
  637.  
  638.          return (Local_Float);
  639.       }
  640.  
  641.       void Parse_Vector (Given_Vector)
  642.          VECTOR *Given_Vector;
  643.       {
  644.          CONSTANT Constant_Id;
  645.  
  646.          EXPECT
  647.          CASE (IDENTIFIER_TOKEN)
  648.             if ((Constant_Id = Find_Constant()) != -1)
  649.                if (Constants[(int)Constant_Id].Constant_Type == VECTOR_CONSTANT)
  650.                   *Given_Vector = *((VECTOR *) Constants[(int)Constant_Id].Constant_Data);
  651.                else
  652.                   Type_Error ();
  653.             else
  654.                Undeclared ();
  655.          EXIT
  656.          END_CASE
  657.  
  658.          CASE (LEFT_ANGLE_TOKEN)
  659.             (Given_Vector -> x) = Parse_Float();
  660.          (Given_Vector -> y) = Parse_Float();
  661.          (Given_Vector -> z) = Parse_Float();
  662.          GET (RIGHT_ANGLE_TOKEN);
  663.          EXIT
  664.          END_CASE
  665.  
  666.          OTHERWISE 
  667.          Parse_Error (LEFT_ANGLE_TOKEN);
  668.          END_CASE
  669.          END_EXPECT
  670.       }
  671.  
  672.       void Parse_Coeffs(order, Given_Coeffs)
  673.          int order;
  674.       DBL *Given_Coeffs;
  675.       {
  676.          int i;
  677.  
  678.          EXPECT
  679.          CASE (LEFT_ANGLE_TOKEN)
  680.             for (i = 0; i < term_counts[order]; i++)
  681.                Given_Coeffs[i] = Parse_Float();
  682.          GET (RIGHT_ANGLE_TOKEN);
  683.          EXIT
  684.          END_CASE
  685.  
  686.          OTHERWISE 
  687.          Parse_Error (LEFT_ANGLE_TOKEN);
  688.          END_CASE
  689.          END_EXPECT
  690.       }
  691.  
  692.       void Parse_Colour (Given_Colour)
  693.          COLOUR *Given_Colour;
  694.       {
  695.          CONSTANT Constant_Id;
  696.          Make_Colour (Given_Colour, 0.0, 0.0, 0.0);
  697.          EXPECT
  698.          CASE (IDENTIFIER_TOKEN)
  699.             if ((Constant_Id = Find_Constant()) != -1)
  700.                if (Constants[(int)Constant_Id].Constant_Type == COLOUR_CONSTANT)
  701.                   *Given_Colour = *((COLOUR *) Constants[(int)Constant_Id].Constant_Data);
  702.                else
  703.                   Type_Error ();
  704.             else
  705.                Undeclared ();
  706.          END_CASE
  707.  
  708.          CASE (RED_TOKEN)
  709.             (Given_Colour -> Red) = Parse_Float();
  710.          END_CASE
  711.  
  712.          CASE (GREEN_TOKEN)
  713.             (Given_Colour -> Green) = Parse_Float();
  714.          END_CASE
  715.  
  716.          CASE (BLUE_TOKEN)
  717.             (Given_Colour -> Blue) = Parse_Float();
  718.          END_CASE
  719.  
  720.          CASE (ALPHA_TOKEN)
  721.             (Given_Colour -> Alpha) = Parse_Float();
  722.          END_CASE
  723.  
  724.          OTHERWISE
  725.          UNGET
  726.          EXIT
  727.          END_CASE
  728.          END_EXPECT
  729.       }
  730.  
  731.       COLOUR_MAP *Parse_Colour_Map ()
  732.       {
  733. #define MAX_ENTRIES 20
  734.          COLOUR_MAP *New_Colour_Map;
  735.  
  736.  
  737.          register int i, j;
  738.  
  739.          if ((New_Colour_Map = (COLOUR_MAP *) malloc (sizeof (COLOUR_MAP))) == NULL)
  740.             Error ("Not enough memory for colour map.");
  741.  
  742.  
  743.          if (Construction_Map == NULL)
  744.             if ((Construction_Map = (COLOUR_MAP_ENTRY *)
  745.                malloc(MAX_ENTRIES * sizeof (COLOUR_MAP_ENTRY))) == NULL)
  746.                Error ("Not enough memory for colour map.");
  747.  
  748.          i = 0;
  749.          New_Colour_Map->Transparency_Flag = FALSE;
  750.          GET(LEFT_CURLY_TOKEN);
  751.          EXPECT
  752.          CASE (LEFT_SQUARE_TOKEN)
  753.             Construction_Map [i].start = Parse_Float();
  754.          Construction_Map [i].end = Parse_Float();
  755.  
  756.          GET (COLOUR_TOKEN);
  757.          Parse_Colour (&(Construction_Map[i].Start_Colour));
  758.          if (Construction_Map[i].Start_Colour.Alpha != 0.0)
  759.             New_Colour_Map->Transparency_Flag = TRUE;
  760.  
  761.          GET (COLOUR_TOKEN);
  762.          Parse_Colour (&(Construction_Map[i].End_Colour));
  763.          if (Construction_Map[i].End_Colour.Alpha != 0.0)
  764.             New_Colour_Map->Transparency_Flag = TRUE;
  765.  
  766.          i++;
  767.          if (i > MAX_ENTRIES)
  768.             Error ("Colour_Map too long.");
  769.          GET (RIGHT_SQUARE_TOKEN);
  770.          END_CASE
  771.  
  772.          CASE (RIGHT_CURLY_TOKEN)
  773.             New_Colour_Map -> Number_Of_Entries = i;
  774.  
  775.          if ((New_Colour_Map -> Colour_Map_Entries = (COLOUR_MAP_ENTRY *)
  776.             malloc(sizeof(COLOUR_MAP_ENTRY) * i)) == NULL)
  777.             Error ("Not enough memory for colour map.");
  778.  
  779.          for (j = 0 ; j < i ; j++)
  780.             New_Colour_Map->Colour_Map_Entries[j] = Construction_Map[j];
  781.  
  782.          EXIT
  783.          END_CASE
  784.  
  785.          OTHERWISE
  786.          Parse_Error (RIGHT_CURLY_TOKEN);
  787.          END_CASE
  788.          END_EXPECT
  789.  
  790.          return (New_Colour_Map);
  791.       }
  792.  
  793.       TEXTURE *Copy_Texture (Texture)
  794.          TEXTURE *Texture;
  795.       {
  796.          TEXTURE *New_Texture, *Local_Texture, *First_Texture, *Previous_Texture;
  797.  
  798.          Previous_Texture = First_Texture = NULL;
  799.  
  800.          for (Local_Texture = Texture ; Local_Texture != NULL ; Local_Texture = Local_Texture->Next_Texture)  {
  801.             New_Texture = Get_Texture();
  802.             *New_Texture = *Local_Texture;
  803.  
  804.             if (First_Texture == NULL)
  805.                First_Texture = New_Texture;
  806.  
  807.             if (Previous_Texture != NULL)
  808.                Previous_Texture->Next_Texture = New_Texture;
  809.  
  810.             if (New_Texture->Texture_Transformation) {
  811.                if ((New_Texture->Texture_Transformation = (TRANSFORMATION *) malloc (sizeof (TRANSFORMATION))) == NULL)
  812.                   Error("Out of memory. Cannot allocate texture transformation");
  813.                *New_Texture->Texture_Transformation = *Local_Texture->Texture_Transformation;
  814.             }
  815.             New_Texture->Constant_Flag = FALSE;
  816.             Previous_Texture = New_Texture;
  817.          }            
  818.          return (First_Texture);
  819.       }
  820.  
  821.       TEXTURE *Parse_Texture ()
  822.       {
  823.          VECTOR Local_Vector;
  824.          TRANSFORMATION Local_Transformation;
  825.          CONSTANT Constant_Id;
  826.          TEXTURE *Texture, *Local_Texture, *First_Texture;
  827.          TEXTURE *temp_texture;
  828.          int reg;
  829.  
  830.          Texture = Default_Texture;
  831.  
  832.          GET(LEFT_CURLY_TOKEN);
  833.  
  834.          EXPECT
  835.          CASE (IDENTIFIER_TOKEN)
  836.             if ((Constant_Id = Find_Constant()) != -1)
  837.                if (Constants[(int)Constant_Id].Constant_Type == TEXTURE_CONSTANT) {
  838.                   Texture = ((TEXTURE *) Constants[(int)Constant_Id].Constant_Data);
  839.                }
  840.                else
  841.                   Type_Error ();
  842.             else
  843.                Undeclared ();
  844.          END_CASE
  845.  
  846.          CASE (FLOAT_TOKEN)
  847.             UNGET
  848.             if (Texture->Constant_Flag) {
  849.                Texture = Copy_Texture(Texture);
  850.                Texture->Constant_Flag = FALSE;
  851.             }
  852.          Texture -> Texture_Randomness = Parse_Float();
  853.          END_CASE
  854.  
  855.          CASE (ONCE_TOKEN)
  856.             if (Texture->Constant_Flag) {
  857.                Texture = Copy_Texture(Texture);
  858.                Texture->Constant_Flag = FALSE;
  859.             }
  860.          Texture->Once_Flag = TRUE;
  861.          END_CASE
  862.  
  863.          CASE (TURBULENCE_TOKEN)
  864.             if (Texture->Constant_Flag) {
  865.                Texture = Copy_Texture(Texture);
  866.                Texture->Constant_Flag = FALSE;
  867.             }
  868.          Texture -> Turbulence = Parse_Float();
  869.          END_CASE
  870.  
  871.          CASE (OCTAVES_TOKEN)                  /* dmf 02/05 for turb */
  872.             if (Texture->Constant_Flag) {
  873.                Texture = Copy_Texture(Texture);
  874.                Texture->Constant_Flag = FALSE;
  875.             }
  876.          Texture->Octaves = (int) Parse_Float();
  877.          if(Texture->Octaves < 1)
  878.             Texture->Octaves = 6;
  879.          if(Texture->Octaves > 10)  /* Avoid DOMAIN errors */
  880.             Texture->Octaves = 10;
  881.          END_CASE
  882.  
  883.          CASE (BOZO_TOKEN)
  884.             if (Texture->Constant_Flag) {
  885.                Texture = Copy_Texture (Texture);
  886.                Texture->Constant_Flag = FALSE;
  887.             }
  888.          Texture -> Texture_Number = BOZO_TEXTURE;
  889.          END_CASE
  890.  
  891.          CASE (MORTAR_TOKEN)
  892.             if (Texture->Constant_Flag) {
  893.                Texture = Copy_Texture (Texture);
  894.                Texture->Constant_Flag = FALSE;
  895.             }
  896.          Texture->Mortar = Parse_Float();
  897.          if (Texture->Mortar < 0)
  898.             Texture->Mortar = 0.2;
  899.          END_CASE
  900.  
  901.          CASE (BRICK_TOKEN)
  902.             if (Texture->Constant_Flag) {
  903.                Texture = Copy_Texture (Texture);
  904.                Texture->Constant_Flag = FALSE;
  905.             }
  906.          Texture -> Texture_Number = BRICK_TEXTURE;
  907.          EXPECT
  908.          CASE (COLOUR_TOKEN)
  909.             Texture->Colour1 = Get_Colour();
  910.          Texture->Colour2 = Get_Colour();
  911.          Parse_Colour (Texture -> Colour1);
  912.          GET (COLOUR_TOKEN);
  913.          Parse_Colour (Texture -> Colour2);
  914.          END_CASE
  915.  
  916.          OTHERWISE
  917.          UNGET
  918.          EXIT
  919.          END_CASE
  920.          END_EXPECT
  921.          END_CASE
  922.  
  923.          CASE (CHECKER_TOKEN)
  924.             if (Texture->Constant_Flag) {
  925.                Texture = Copy_Texture (Texture);
  926.                Texture->Constant_Flag = FALSE;
  927.             }
  928.          Texture -> Texture_Number = CHECKER_TEXTURE;
  929.          EXPECT
  930.          CASE (COLOUR_TOKEN)
  931.             Texture->Colour1 = Get_Colour();
  932.          Texture->Colour2 = Get_Colour();
  933.          Parse_Colour (Texture -> Colour1);
  934.          GET (COLOUR_TOKEN);
  935.          Parse_Colour (Texture -> Colour2);
  936.          END_CASE
  937.  
  938.          OTHERWISE
  939.          UNGET
  940.          EXIT
  941.          END_CASE
  942.          END_EXPECT
  943.          END_CASE
  944.  
  945.          CASE (CHECKER_TEXTURE_TOKEN)
  946.             if (Texture->Constant_Flag) {
  947.                Texture = Copy_Texture (Texture);
  948.                Texture->Constant_Flag = FALSE;
  949.             }
  950.          Texture -> Texture_Number = CHECKER_TEXTURE_TEXTURE;
  951.  
  952.          GET(LEFT_CURLY_TOKEN);
  953.  
  954.          EXPECT
  955.          CASE (TEXTURE_TOKEN)
  956.             Local_Texture = Parse_Texture ();
  957.          if (Local_Texture->Constant_Flag)
  958.             Local_Texture = Copy_Texture(Local_Texture);
  959.  
  960.          {
  961.             for (temp_texture = Local_Texture ;
  962.                            temp_texture->Next_Texture != NULL ;
  963.                            temp_texture = temp_texture->Next_Texture)
  964.             {}
  965.  
  966.             temp_texture->Next_Texture = (TEXTURE *) Texture->Colour1;
  967.             Texture->Colour1 = (COLOUR *) Local_Texture;
  968.          }
  969.          END_CASE
  970.          OTHERWISE
  971.          UNGET
  972.          EXIT
  973.          END_CASE
  974.          END_EXPECT
  975.  
  976.          GET (TILE2_TOKEN);
  977.          EXPECT
  978.          CASE (TEXTURE_TOKEN)
  979.             Local_Texture = Parse_Texture ();
  980.          if (Local_Texture->Constant_Flag)
  981.             Local_Texture = Copy_Texture(Local_Texture);
  982.  
  983.          {
  984.             for (temp_texture = Local_Texture ;
  985.                            temp_texture->Next_Texture != NULL ;
  986.                            temp_texture = temp_texture->Next_Texture)
  987.             {}
  988.  
  989.             temp_texture->Next_Texture = (TEXTURE *) Texture->Colour2;
  990.             Texture->Colour2 = (COLOUR *) Local_Texture;
  991.          }
  992.          END_CASE
  993.          OTHERWISE
  994.          UNGET
  995.          EXIT
  996.          END_CASE
  997.          END_EXPECT
  998.          GET (RIGHT_CURLY_TOKEN);
  999.          END_CASE
  1000.  
  1001.          CASE (MARBLE_TOKEN)
  1002.             if (Texture->Constant_Flag) {
  1003.                Texture = Copy_Texture (Texture);
  1004.                Texture->Constant_Flag = FALSE;
  1005.             }
  1006.          Texture -> Texture_Number = MARBLE_TEXTURE;
  1007.          END_CASE
  1008.  
  1009.          CASE (WOOD_TOKEN)
  1010.             if (Texture->Constant_Flag) {
  1011.                Texture = Copy_Texture (Texture);
  1012.                Texture->Constant_Flag = FALSE;
  1013.             }
  1014.          Texture -> Texture_Number = WOOD_TEXTURE;
  1015.          END_CASE
  1016.  
  1017.          CASE (SPOTTED_TOKEN)
  1018.             if (Texture->Constant_Flag) {
  1019.                Texture = Copy_Texture (Texture);
  1020.                Texture->Constant_Flag = FALSE;
  1021.             }
  1022.          Texture -> Texture_Number = SPOTTED_TEXTURE;
  1023.          END_CASE
  1024.  
  1025.          CASE (AGATE_TOKEN)
  1026.             if (Texture->Constant_Flag) {
  1027.                Texture = Copy_Texture (Texture);
  1028.                Texture->Constant_Flag = FALSE;
  1029.             }
  1030.          Texture -> Texture_Number = AGATE_TEXTURE;
  1031.          END_CASE
  1032.  
  1033.          CASE (GRANITE_TOKEN)
  1034.             if (Texture->Constant_Flag) {
  1035.                Texture = Copy_Texture (Texture);
  1036.                Texture->Constant_Flag = FALSE;
  1037.             }
  1038.          Texture -> Texture_Number = GRANITE_TEXTURE;
  1039.          END_CASE
  1040.  
  1041.          CASE (GRADIENT_TOKEN)
  1042.             if (Texture->Constant_Flag) {
  1043.                Texture = Copy_Texture (Texture);
  1044.                Texture->Constant_Flag = FALSE;
  1045.             }
  1046.          Texture -> Texture_Number = GRADIENT_TEXTURE;
  1047.          Parse_Vector (&(Texture -> Texture_Gradient));
  1048.          END_CASE
  1049.  
  1050.          CASE (AMBIENT_TOKEN)
  1051.             if (Texture->Constant_Flag) {
  1052.                Texture = Copy_Texture (Texture);
  1053.                Texture->Constant_Flag = FALSE;
  1054.             }
  1055.          (Texture -> Object_Ambient) = Parse_Float ();
  1056.          END_CASE
  1057.  
  1058.          CASE (BRILLIANCE_TOKEN)
  1059.             if (Texture->Constant_Flag) {
  1060.                Texture = Copy_Texture (Texture);
  1061.                Texture->Constant_Flag = FALSE;
  1062.             }
  1063.          (Texture -> Object_Brilliance) = Parse_Float ();
  1064.          END_CASE
  1065.  
  1066.          CASE (ROUGHNESS_TOKEN)
  1067.             if (Texture->Constant_Flag) {
  1068.                Texture = Copy_Texture (Texture);
  1069.                Texture->Constant_Flag = FALSE;
  1070.             }
  1071.          (Texture -> Object_Roughness) = Parse_Float ();
  1072.          /* No training wheels */
  1073.          /* if (Texture -> Object_Roughness > 1.0)
  1074.         Texture -> Object_Roughness = 1.0;
  1075.      if (Texture -> Object_Roughness < 0.001)
  1076.         Texture -> Object_Roughness = 0.001; */
  1077.          END_CASE
  1078.  
  1079.          CASE (PHONGSIZE_TOKEN)
  1080.             if (Texture->Constant_Flag) {
  1081.                Texture = Copy_Texture (Texture);
  1082.                Texture->Constant_Flag = FALSE;
  1083.             }
  1084.          (Texture -> Object_PhongSize) = Parse_Float ();
  1085.          /* No training wheels */
  1086.          /*if (Texture -> Object_PhongSize < 1.0)
  1087.         Texture -> Object_PhongSize = 1.0;
  1088.      if (Texture -> Object_PhongSize > 100)
  1089.         Texture -> Object_PhongSize = 100; */
  1090.          END_CASE
  1091.  
  1092.          CASE (DIFFUSE_TOKEN)
  1093.             if (Texture->Constant_Flag) {
  1094.                Texture = Copy_Texture (Texture);
  1095.                Texture->Constant_Flag = FALSE;
  1096.             }
  1097.          (Texture -> Object_Diffuse) = Parse_Float ();
  1098.          END_CASE
  1099.  
  1100.          CASE (SPECULAR_TOKEN)
  1101.             if (Texture->Constant_Flag) {
  1102.                Texture = Copy_Texture (Texture);
  1103.                Texture->Constant_Flag = FALSE;
  1104.             }
  1105.          (Texture -> Object_Specular) = Parse_Float ();
  1106.          END_CASE
  1107.  
  1108.          CASE (PHONG_TOKEN)
  1109.             if (Texture->Constant_Flag) {
  1110.                Texture = Copy_Texture (Texture);
  1111.                Texture->Constant_Flag = FALSE;
  1112.             }
  1113.          (Texture -> Object_Phong) = Parse_Float ();
  1114.          END_CASE
  1115.  
  1116.          CASE (METALLIC_TOKEN)
  1117.             if (Texture->Constant_Flag) {
  1118.                Texture = Copy_Texture (Texture);
  1119.                Texture->Constant_Flag = FALSE;
  1120.             }
  1121.          Texture -> Metallic_Flag = TRUE;
  1122.          END_CASE
  1123.  
  1124.          CASE (IOR_TOKEN)
  1125.             if (Texture->Constant_Flag) {
  1126.                Texture = Copy_Texture (Texture);
  1127.                Texture->Constant_Flag = FALSE;
  1128.             }
  1129.          (Texture -> Object_Index_Of_Refraction) = Parse_Float ();
  1130.          END_CASE
  1131.  
  1132.          CASE (REFRACTION_TOKEN)
  1133.             if (Texture->Constant_Flag) {
  1134.                Texture = Copy_Texture (Texture);
  1135.                Texture->Constant_Flag = FALSE;
  1136.             }
  1137.          (Texture -> Object_Refraction) = Parse_Float ();
  1138.          END_CASE
  1139.  
  1140.          CASE (TRANSMIT_TOKEN)
  1141.             if (Texture->Constant_Flag) {
  1142.                Texture = Copy_Texture (Texture);
  1143.                Texture->Constant_Flag = FALSE;
  1144.             }
  1145.          (Texture -> Object_Transmit) = Parse_Float ();
  1146.          END_CASE
  1147.  
  1148.          CASE (REFLECTION_TOKEN)
  1149.             if (Texture->Constant_Flag) {
  1150.                Texture = Copy_Texture (Texture);
  1151.                Texture->Constant_Flag = FALSE;
  1152.             }
  1153.          (Texture -> Object_Reflection) = Parse_Float ();
  1154.          END_CASE
  1155.  
  1156.          CASE (IMAGEMAP_TOKEN)
  1157.             if (Texture->Constant_Flag) {
  1158.                Texture = Copy_Texture (Texture);
  1159.                Texture->Constant_Flag = FALSE;
  1160.             }
  1161.          Texture->Texture_Number = IMAGEMAP_TEXTURE;
  1162.          if ((Texture->Image = (IMAGE *)malloc(sizeof(IMAGE))) == NULL)
  1163.             Error("Out of memory. Cannot allocate imagemap texture");
  1164.          Make_Vector (&Texture->Image->Image_Gradient, 1.0, -1.0, 0.0);
  1165.          Texture->Image->Map_Type = PLANAR_MAP;  
  1166.          Texture->Image->Interpolation_Type = NO_INTERPOLATION;
  1167.          Texture->Image->Once_Flag = FALSE;
  1168.          Texture->Image->Use_Colour_Flag= TRUE;
  1169.  
  1170.          GET(LEFT_CURLY_TOKEN);   
  1171.  
  1172.          EXPECT
  1173.          CASE3 (DASH_TOKEN, PLUS_TOKEN, FLOAT_TOKEN)
  1174.             UNGET
  1175.             (Texture->Image->Map_Type) = (int) Parse_Float ();
  1176.          END_CASE
  1177.  
  1178.          CASE (LEFT_ANGLE_TOKEN)
  1179.             UNGET
  1180.             Parse_Vector (&(Texture -> Image->Image_Gradient));
  1181.          END_CASE
  1182.  
  1183.          CASE (IFF_TOKEN)
  1184.             GET (STRING_TOKEN);
  1185.          Read_Iff_Image(Texture->Image, Token.Token_String);
  1186.          EXIT
  1187.          END_CASE
  1188.  
  1189.          CASE (GIF_TOKEN)
  1190.             GET (STRING_TOKEN);
  1191.          Read_Gif_Image(Texture->Image, Token.Token_String);
  1192.          EXIT
  1193.          END_CASE
  1194.  
  1195.          CASE (TGA_TOKEN)
  1196.             GET (STRING_TOKEN);
  1197.          Read_Targa_Image(Texture->Image, Token.Token_String);
  1198.          EXIT
  1199.          END_CASE
  1200.  
  1201.          CASE (DUMP_TOKEN)
  1202.             GET (STRING_TOKEN);
  1203.          Read_Dump_Image(Texture->Image, Token.Token_String);
  1204.          EXIT
  1205.          END_CASE
  1206.  
  1207.          OTHERWISE
  1208.          Parse_Error (GIF_TOKEN);
  1209.          END_CASE
  1210.          END_EXPECT
  1211.  
  1212.          EXPECT
  1213.          CASE (ONCE_TOKEN)
  1214.             Texture->Image->Once_Flag=TRUE;
  1215.          END_CASE
  1216.  
  1217.          CASE (INTERPOLATE_TOKEN)
  1218.             Texture->Image->Interpolation_Type = (int)Parse_Float();
  1219.          END_CASE
  1220.  
  1221.          CASE (MAPTYPE_TOKEN)
  1222.             (Texture->Image->Map_Type) = (int) Parse_Float ();
  1223.          END_CASE
  1224.  
  1225.          CASE (USE_COLOUR_TOKEN)
  1226.             Texture ->Image->Use_Colour_Flag = TRUE;
  1227.          END_CASE  
  1228.  
  1229.          CASE (USE_INDEX_TOKEN)
  1230.             Texture ->Image->Use_Colour_Flag = FALSE;
  1231.          END_CASE  
  1232.  
  1233.          CASE (ALPHA_TOKEN)
  1234.             EXPECT
  1235.             CASE (FLOAT_TOKEN)
  1236.                reg = (int)(Token.Token_Float + 0.01);
  1237.          if (Texture->Image->Colour_Map == NULL)
  1238.             Error ("Can't apply ALPHA to a non colour-mapped image\n");
  1239.  
  1240.          if ((reg < 0) || (reg >= Texture->Image->Colour_Map_Size))
  1241.             Error ("ALPHA colour register value out of range.\n");
  1242.  
  1243.          Texture->Image->Colour_Map[reg].Alpha = (unsigned short) (255.0 * Parse_Float());
  1244.          EXIT
  1245.          END_CASE
  1246.  
  1247.          CASE (ALL_TOKEN)
  1248.          {
  1249.             DBL alpha;
  1250.             alpha = Parse_Float();
  1251.  
  1252.             for (reg = 0 ; reg < Texture->Image->Colour_Map_Size ; reg++)
  1253.                Texture->Image->Colour_Map[reg].Alpha = (unsigned short) (alpha *255.0);
  1254.             EXIT
  1255.          }
  1256.  
  1257.          END_CASE
  1258.          END_EXPECT
  1259.          END_CASE
  1260.  
  1261.          CASE (RIGHT_CURLY_TOKEN)
  1262.             EXIT
  1263.             END_CASE
  1264.  
  1265.             OTHERWISE
  1266.             Parse_Error (RIGHT_CURLY_TOKEN);
  1267.          END_CASE
  1268.          END_EXPECT
  1269.          END_CASE
  1270.  
  1271.          CASE (WAVES_TOKEN)
  1272.             if (Texture->Constant_Flag) {
  1273.                Texture = Copy_Texture (Texture);
  1274.                Texture->Constant_Flag = FALSE;
  1275.             }
  1276.          Texture -> Bump_Number = WAVES;
  1277.          Texture -> Bump_Amount = Parse_Float ();
  1278.          EXPECT
  1279.          CASE (PHASE_TOKEN)
  1280.             Texture -> Phase = Parse_Float();
  1281.          EXIT
  1282.          END_CASE
  1283.  
  1284.          OTHERWISE
  1285.          UNGET
  1286.          EXIT
  1287.          END_CASE
  1288.          END_EXPECT
  1289.          END_CASE
  1290.  
  1291.          CASE (FREQUENCY_TOKEN)
  1292.             if (Texture->Constant_Flag) {
  1293.                Texture = Copy_Texture (Texture);
  1294.                Texture->Constant_Flag = FALSE;
  1295.             }
  1296.          Texture -> Frequency = Parse_Float();
  1297.          END_CASE
  1298.  
  1299.          CASE (PHASE_TOKEN)
  1300.             if (Texture->Constant_Flag) {
  1301.                Texture = Copy_Texture (Texture);
  1302.                Texture->Constant_Flag = FALSE;
  1303.             }
  1304.          Texture -> Phase = Parse_Float();
  1305.          END_CASE
  1306.  
  1307.          CASE (RIPPLES_TOKEN)
  1308.             if (Texture->Constant_Flag) {
  1309.                Texture = Copy_Texture (Texture);
  1310.                Texture->Constant_Flag = FALSE;
  1311.             }
  1312.          Texture -> Bump_Number = RIPPLES;
  1313.          Texture -> Bump_Amount = Parse_Float ();
  1314.          END_CASE
  1315.  
  1316.          CASE (WRINKLES_TOKEN)
  1317.             if (Texture->Constant_Flag) {
  1318.                Texture = Copy_Texture (Texture);
  1319.                Texture->Constant_Flag = FALSE;
  1320.             }
  1321.          Texture -> Bump_Number = WRINKLES;
  1322.          Texture -> Bump_Amount = Parse_Float ();
  1323.          END_CASE
  1324.  
  1325.          CASE (BUMPS_TOKEN)
  1326.             if (Texture->Constant_Flag) {
  1327.                Texture = Copy_Texture (Texture);
  1328.                Texture->Constant_Flag = FALSE;
  1329.             }
  1330.          Texture -> Bump_Number = BUMPS;
  1331.          Texture -> Bump_Amount = Parse_Float ();
  1332.          END_CASE
  1333.  
  1334.          CASE (DENTS_TOKEN)
  1335.             if (Texture->Constant_Flag) {
  1336.                Texture = Copy_Texture (Texture);
  1337.                Texture->Constant_Flag = FALSE;
  1338.             }
  1339.          Texture -> Bump_Number = DENTS;
  1340.          Texture -> Bump_Amount = Parse_Float ();
  1341.          END_CASE
  1342.  
  1343.          CASE (TRANSLATE_TOKEN)
  1344.             if (Texture->Constant_Flag) {
  1345.                Texture = Copy_Texture (Texture);
  1346.                Texture->Constant_Flag = FALSE;
  1347.             }
  1348.          Parse_Vector (&Local_Vector);
  1349.          Translate_Texture (&Texture, &Local_Vector);
  1350.          END_CASE
  1351.  
  1352.          CASE (ROTATE_TOKEN)
  1353.             if (Texture->Constant_Flag) {
  1354.                Texture = Copy_Texture (Texture);
  1355.                Texture->Constant_Flag = FALSE;
  1356.             }
  1357.          Parse_Vector (&Local_Vector);
  1358.          Rotate_Texture (&Texture, &Local_Vector);
  1359.          END_CASE
  1360.  
  1361.          CASE (SCALE_TOKEN)
  1362.             if (Texture->Constant_Flag) {
  1363.                Texture = Copy_Texture (Texture);
  1364.                Texture->Constant_Flag = FALSE;
  1365.             }
  1366.          Parse_Vector (&Local_Vector);
  1367.          Scale_Texture (&Texture, &Local_Vector);
  1368.          END_CASE
  1369.  
  1370.          CASE (COLOUR_TOKEN)
  1371.             if (Texture->Constant_Flag) {
  1372.                Texture = Copy_Texture (Texture);
  1373.                Texture->Constant_Flag = FALSE;
  1374.             }
  1375.          Texture->Colour1 = Get_Colour();
  1376.          Parse_Colour (Texture -> Colour1);
  1377.          Texture -> Texture_Number = COLOUR_TEXTURE;
  1378.          END_CASE
  1379.  
  1380.          CASE (COLOUR_MAP_TOKEN)
  1381.             if (Texture->Constant_Flag) {
  1382.                Texture = Copy_Texture (Texture);
  1383.                Texture->Constant_Flag = FALSE;
  1384.             }
  1385.          Texture -> Colour_Map = Parse_Colour_Map();
  1386.          END_CASE
  1387.  
  1388.          CASE (ONION_TOKEN)
  1389.             if (Texture->Constant_Flag) {
  1390.                Texture = Copy_Texture (Texture);
  1391.                Texture->Constant_Flag = FALSE;
  1392.             }
  1393.          Texture -> Texture_Number = ONION_TEXTURE;
  1394.          END_CASE
  1395.  
  1396.          CASE (LEOPARD_TOKEN)
  1397.             if (Texture->Constant_Flag) {
  1398.                Texture = Copy_Texture (Texture);
  1399.                Texture->Constant_Flag = FALSE;
  1400.             }
  1401.          Texture -> Texture_Number = LEOPARD_TEXTURE;
  1402.          END_CASE
  1403.  
  1404.  
  1405.  
  1406.          /* New Texture Parsing - Cdw */
  1407.          CASE (PAINTED1_TOKEN)
  1408.             if (Texture->Constant_Flag) {
  1409.                Texture = Copy_Texture (Texture);
  1410.                Texture->Constant_Flag = FALSE;
  1411.             }
  1412.          Texture -> Texture_Number = PAINTED1_TEXTURE;
  1413.          END_CASE
  1414.  
  1415.          CASE (PAINTED2_TOKEN)
  1416.             if (Texture->Constant_Flag) {
  1417.                Texture = Copy_Texture (Texture);
  1418.                Texture->Constant_Flag = FALSE;
  1419.             }
  1420.          Texture -> Texture_Number = PAINTED2_TEXTURE;
  1421.          END_CASE
  1422.  
  1423.          CASE (PAINTED3_TOKEN)
  1424.             if (Texture->Constant_Flag) {
  1425.                Texture = Copy_Texture (Texture);
  1426.                Texture->Constant_Flag = FALSE;
  1427.             }
  1428.          Texture -> Texture_Number = PAINTED3_TEXTURE;
  1429.          END_CASE
  1430.  
  1431.          CASE (BUMPY1_TOKEN)
  1432.             if (Texture->Constant_Flag) {
  1433.                Texture = Copy_Texture (Texture);
  1434.                Texture->Constant_Flag = FALSE;
  1435.             }
  1436.          Texture -> Bump_Number = BUMPY1;
  1437.          Texture -> Bump_Amount = Parse_Float ();
  1438.          END_CASE
  1439.  
  1440.          CASE (BUMPY2_TOKEN)
  1441.             if (Texture->Constant_Flag) {
  1442.                Texture = Copy_Texture (Texture);
  1443.                Texture->Constant_Flag = FALSE;
  1444.             }
  1445.          Texture -> Bump_Number = BUMPY2;
  1446.          Texture -> Bump_Amount = Parse_Float ();
  1447.          END_CASE
  1448.  
  1449.          CASE (BUMPY3_TOKEN)
  1450.             if (Texture->Constant_Flag) {
  1451.                Texture = Copy_Texture (Texture);
  1452.                Texture->Constant_Flag = FALSE;
  1453.             }
  1454.          Texture -> Bump_Number = BUMPY3;
  1455.          Texture -> Bump_Amount = Parse_Float ();
  1456.          END_CASE
  1457.  
  1458.  
  1459.          CASE (BUMPMAP_TOKEN)
  1460.             if (Texture->Constant_Flag) {
  1461.                Texture = Copy_Texture (Texture);
  1462.                Texture->Constant_Flag = FALSE;
  1463.             }
  1464.          Texture -> Bump_Number = BUMPMAP;
  1465.          if ((Texture->Bump_Image = (IMAGE *)malloc(sizeof(IMAGE))) == NULL)
  1466.             Error("Out of memory. Cannot allocate bumpmap texture");
  1467.          Make_Vector (&Texture->Bump_Image->Image_Gradient, 1.0, -1.0, 0.0);
  1468.          Texture->Bump_Image->Map_Type = PLANAR_MAP;  
  1469.          Texture->Bump_Image->Interpolation_Type = NO_INTERPOLATION;
  1470.          Texture->Bump_Image->Once_Flag = FALSE;
  1471.          Texture->Bump_Image->Use_Colour_Flag = TRUE;
  1472.  
  1473.          GET(LEFT_CURLY_TOKEN);    
  1474.  
  1475.          EXPECT
  1476.          CASE3 (DASH_TOKEN, PLUS_TOKEN, FLOAT_TOKEN)
  1477.             UNGET
  1478.             (Texture->Bump_Image->Map_Type) = (int) Parse_Float ();
  1479.          END_CASE            
  1480.  
  1481.          CASE (LEFT_ANGLE_TOKEN)
  1482.             UNGET
  1483.             Parse_Vector (&(Texture ->Bump_Image->Image_Gradient));
  1484.          END_CASE
  1485.  
  1486.          CASE (IFF_TOKEN)
  1487.             GET (STRING_TOKEN);
  1488.          Read_Iff_Image(Texture->Bump_Image, Token.Token_String);
  1489.          EXIT
  1490.          END_CASE
  1491.  
  1492.          CASE (GIF_TOKEN)
  1493.             GET (STRING_TOKEN);
  1494.          Read_Gif_Image(Texture->Bump_Image, Token.Token_String);
  1495.          EXIT
  1496.          END_CASE
  1497.  
  1498.          CASE (TGA_TOKEN)
  1499.             GET (STRING_TOKEN);
  1500.          Read_Targa_Image(Texture->Bump_Image, Token.Token_String);
  1501.          EXIT
  1502.          END_CASE
  1503.  
  1504.          CASE (DUMP_TOKEN)
  1505.             GET (STRING_TOKEN);
  1506.          Read_Dump_Image(Texture->Bump_Image, Token.Token_String);
  1507.          EXIT
  1508.          END_CASE
  1509.  
  1510.          OTHERWISE
  1511.          Parse_Error (GIF_TOKEN);
  1512.          END_CASE
  1513.          END_EXPECT
  1514.  
  1515.          EXPECT
  1516.          CASE (ONCE_TOKEN)
  1517.             Texture->Bump_Image->Once_Flag=TRUE;
  1518.          END_CASE          
  1519.  
  1520.          CASE (MAPTYPE_TOKEN)
  1521.             (Texture->Bump_Image->Map_Type) = (int) Parse_Float ();
  1522.          END_CASE
  1523.  
  1524.          CASE (INTERPOLATE_TOKEN)
  1525.             Texture->Bump_Image->Interpolation_Type = (int)Parse_Float();
  1526.          END_CASE
  1527.  
  1528.          CASE (BUMPSIZE_TOKEN)
  1529.             Texture -> Bump_Amount = Parse_Float ();
  1530.          END_CASE  
  1531.  
  1532.          CASE (USE_COLOUR_TOKEN)
  1533.             Texture ->Bump_Image->Use_Colour_Flag = TRUE;
  1534.          END_CASE  
  1535.          CASE (USE_INDEX_TOKEN)
  1536.             Texture ->Bump_Image->Use_Colour_Flag = FALSE;
  1537.          END_CASE  
  1538.  
  1539.          CASE (RIGHT_CURLY_TOKEN)
  1540.             EXIT
  1541.             END_CASE
  1542.  
  1543.             OTHERWISE
  1544.             Parse_Error (RIGHT_CURLY_TOKEN);
  1545.          END_CASE
  1546.          END_EXPECT
  1547.          END_CASE
  1548.  
  1549.  
  1550.          CASE (MATERIAL_MAP_TOKEN)
  1551.  
  1552.             if (Texture->Constant_Flag) {
  1553.                Texture = Copy_Texture (Texture);
  1554.                Texture->Constant_Flag = FALSE;
  1555.             }
  1556.          Texture -> Texture_Number = MATERIAL_MAP_TEXTURE;
  1557.          if ((Texture->Material_Image=(IMAGE *)malloc(sizeof(IMAGE))) == NULL)
  1558.             Error("Out of memory. Cannot allocate material map texture");
  1559.          Make_Vector (&Texture->Texture_Gradient, 1.0, -1.0, 0.0);
  1560.          Texture->Material_Image->Map_Type = PLANAR_MAP;  
  1561.          Texture->Material_Image->Interpolation_Type = NO_INTERPOLATION;
  1562.          Texture->Material_Image->Once_Flag = FALSE;
  1563.          Texture->Material_Image->Use_Colour_Flag = FALSE; 
  1564.  
  1565.          GET(LEFT_CURLY_TOKEN);    
  1566.  
  1567.          EXPECT
  1568.          CASE3 (DASH_TOKEN, PLUS_TOKEN, FLOAT_TOKEN)
  1569.             UNGET
  1570.             (Texture->Image->Map_Type) = (int) Parse_Float ();
  1571.          END_CASE
  1572.  
  1573.          CASE (LEFT_ANGLE_TOKEN)
  1574.             UNGET
  1575.             Parse_Vector (&(Texture ->Material_Image->Image_Gradient));
  1576.          END_CASE
  1577.  
  1578.          CASE (IFF_TOKEN)
  1579.             GET (STRING_TOKEN);
  1580.          Read_Iff_Image(Texture->Material_Image, Token.Token_String);
  1581.          EXIT
  1582.          END_CASE
  1583.  
  1584.          CASE (GIF_TOKEN)
  1585.             GET (STRING_TOKEN);
  1586.          Read_Gif_Image(Texture->Material_Image, Token.Token_String);
  1587.          EXIT
  1588.          END_CASE
  1589.  
  1590.          CASE (TGA_TOKEN)
  1591.             GET (STRING_TOKEN);
  1592.          Read_Targa_Image(Texture->Material_Image, Token.Token_String);
  1593.          EXIT
  1594.          END_CASE
  1595.  
  1596.          CASE (DUMP_TOKEN)
  1597.             GET (STRING_TOKEN);
  1598.          Read_Dump_Image(Texture->Material_Image, Token.Token_String);
  1599.          EXIT
  1600.          END_CASE
  1601.  
  1602.          OTHERWISE
  1603.          Parse_Error (GIF_TOKEN);
  1604.          END_CASE
  1605.          END_EXPECT
  1606.  
  1607.          /* remember where the First_Texture is */
  1608.          First_Texture = Texture; 
  1609.  
  1610.          EXPECT
  1611.  
  1612.          CASE (MAPTYPE_TOKEN)
  1613.             (Texture->Material_Image->Map_Type) = (int) Parse_Float ();
  1614.          END_CASE
  1615.  
  1616.          CASE (INTERPOLATE_TOKEN)
  1617.             Texture->Material_Image->Interpolation_Type=(int)Parse_Float();
  1618.          END_CASE
  1619.  
  1620.          CASE (ONCE_TOKEN)
  1621.             Texture->Material_Image->Once_Flag=TRUE;
  1622.          END_CASE          
  1623.  
  1624.  
  1625.          CASE (TEXTURE_TOKEN) {
  1626.             Texture->Next_Material = Parse_Texture (); 
  1627.             First_Texture->Number_Of_Materials++;
  1628.             Texture = Texture->Next_Material;
  1629.          }
  1630.  
  1631.          END_CASE
  1632.  
  1633.          CASE (RIGHT_CURLY_TOKEN){
  1634.             Texture->Next_Material = NULL; 
  1635.             Texture = First_Texture; 
  1636.             EXIT
  1637.          }
  1638.          END_CASE  
  1639.  
  1640.          OTHERWISE
  1641.          Parse_Error (RIGHT_CURLY_TOKEN);
  1642.          END_CASE
  1643.          END_EXPECT
  1644.          END_CASE
  1645.  
  1646.          CASE (RIGHT_CURLY_TOKEN)
  1647.             EXIT
  1648.             END_CASE
  1649.  
  1650.             OTHERWISE
  1651.             Parse_Error (RIGHT_CURLY_TOKEN);
  1652.          END_CASE
  1653.          END_EXPECT
  1654.          return (Texture);
  1655.       }
  1656.  
  1657.       SHAPE *Parse_Light_Source ()
  1658.       {
  1659.          LIGHT_SHAPE *Local_Shape;
  1660.          VECTOR Local_Vector;
  1661.          CONSTANT Constant_Id;
  1662.  
  1663.  
  1664.          GET (LEFT_CURLY_TOKEN);
  1665.  
  1666.          EXPECT
  1667.          CASE (LEFT_ANGLE_TOKEN)
  1668.             UNGET
  1669.             Local_Shape = Get_Light_Source_Shape();
  1670.          Parse_Vector(&(Local_Shape->Center));
  1671.          Local_Shape->Shape_Colour = Get_Colour();
  1672.          Make_Colour(Local_Shape->Shape_Colour, 1.0, 1.0, 1.0);
  1673.          Local_Shape->Shape_Colour->Alpha = 0.0;
  1674.          GET (COLOUR_TOKEN);
  1675.          Parse_Colour (Local_Shape->Shape_Colour);
  1676.          EXIT
  1677.          END_CASE
  1678.  
  1679.  
  1680.          CASE (IDENTIFIER_TOKEN)
  1681.             if ((Constant_Id = Find_Constant()) != -1)
  1682.                if (Constants[(int)Constant_Id].Constant_Type == LIGHT_SOURCE_CONSTANT)
  1683.                   Local_Shape = (LIGHT_SHAPE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1684.                else 
  1685.                   Type_Error ();
  1686.             else
  1687.                Undeclared ();
  1688.          EXIT
  1689.          END_CASE
  1690.  
  1691.          OTHERWISE
  1692.          Parse_Error (LEFT_ANGLE_TOKEN);
  1693.          END_CASE
  1694.          END_EXPECT
  1695.  
  1696.          EXPECT
  1697.          CASE (RIGHT_CURLY_TOKEN)
  1698.             EXIT
  1699.             END_CASE
  1700.  
  1701.             CASE (TRANSLATE_TOKEN)
  1702.                Parse_Vector (&Local_Vector);
  1703.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1704.          END_CASE
  1705.  
  1706.          CASE (ROTATE_TOKEN)
  1707.             Parse_Vector (&Local_Vector);
  1708.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1709.          END_CASE
  1710.  
  1711.          CASE (SCALE_TOKEN)
  1712.             Parse_Vector (&Local_Vector);
  1713.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1714.          END_CASE
  1715.  
  1716.          /* Point that the spot is pointed at */
  1717.          CASE (POINT_AT_TOKEN)
  1718.             Parse_Vector(&(Local_Shape -> Points_At));
  1719.          END_CASE
  1720.  
  1721.          CASE (TIGHTNESS_TOKEN)
  1722.             Local_Shape -> Coeff = Parse_Float();
  1723.          END_CASE
  1724.  
  1725.          CASE (RADIUS_TOKEN)
  1726.             Local_Shape -> Radius = cos(Parse_Float() * M_PI / 180.0);
  1727.          END_CASE
  1728.  
  1729.          CASE (COLOUR_TOKEN)
  1730.             Parse_Colour (Local_Shape->Shape_Colour);
  1731.          END_CASE
  1732.  
  1733.  
  1734.          CASE (FALLOFF_TOKEN)
  1735.             Local_Shape -> Falloff = cos(Parse_Float() * M_PI / 180.0);
  1736.          END_CASE
  1737.  
  1738.          CASE (SPOTLIGHT_TOKEN)
  1739.             Local_Shape -> Type = SPOT_LIGHT_TYPE;
  1740.          END_CASE
  1741.  
  1742.  
  1743.          OTHERWISE
  1744.          Parse_Error (RIGHT_CURLY_TOKEN);
  1745.          END_CASE
  1746.  
  1747.          END_EXPECT
  1748.          /*  Link_Shapes (Local_Shape, &(Local_Shape -> Next_Light_Source),
  1749.            &(Parsing_Frame_Ptr -> Light_Sources));
  1750. */
  1751.          return ((SHAPE *) Local_Shape);
  1752.       }
  1753.  
  1754.  
  1755.  
  1756.  
  1757.       SHAPE *Parse_Sphere ()
  1758.       {
  1759.          SPHERE *Local_Shape;
  1760.          CONSTANT Constant_Id;
  1761.          VECTOR Local_Vector;
  1762.          TEXTURE *Local_Texture;
  1763.          TEXTURE *temp_texture;
  1764.  
  1765.          Local_Shape = NULL;
  1766.  
  1767.          GET(LEFT_CURLY_TOKEN);
  1768.  
  1769.          EXPECT
  1770.          CASE (LEFT_ANGLE_TOKEN)
  1771.             UNGET
  1772.             Local_Shape = Get_Sphere_Shape();
  1773.          Parse_Vector(&(Local_Shape -> Center));
  1774.          Local_Shape -> Radius = Parse_Float();
  1775.          Local_Shape -> Radius_Squared = Local_Shape -> Radius * Local_Shape -> Radius;
  1776.          Local_Shape -> Inverse_Radius = 1.0 / Local_Shape -> Radius;
  1777.          EXIT
  1778.          END_CASE
  1779.  
  1780.          CASE (IDENTIFIER_TOKEN)
  1781.             if ((Constant_Id = Find_Constant()) != -1)
  1782.                if (Constants[(int)Constant_Id].Constant_Type == SPHERE_CONSTANT)
  1783.                   Local_Shape = (SPHERE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1784.                else
  1785.                   Type_Error ();
  1786.             else
  1787.                Undeclared ();
  1788.          EXIT
  1789.          END_CASE
  1790.  
  1791.          OTHERWISE
  1792.          Parse_Error (LEFT_ANGLE_TOKEN);
  1793.          END_CASE
  1794.          END_EXPECT
  1795.  
  1796.          EXPECT
  1797.          CASE (RIGHT_CURLY_TOKEN)
  1798.             EXIT
  1799.             END_CASE
  1800.  
  1801.             CASE (TRANSLATE_TOKEN)
  1802.                Parse_Vector (&Local_Vector);
  1803.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1804.          END_CASE
  1805.  
  1806.          CASE (ROTATE_TOKEN)
  1807.             Parse_Vector (&Local_Vector);
  1808.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1809.          END_CASE
  1810.  
  1811.          CASE (SCALE_TOKEN)
  1812.             Parse_Vector (&Local_Vector);
  1813.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1814.          END_CASE
  1815.  
  1816.          CASE (INVERSE_TOKEN)
  1817.             Invert ((OBJECT *) Local_Shape);
  1818.          END_CASE
  1819.  
  1820.          CASE (TEXTURE_TOKEN)
  1821.             Local_Texture = Parse_Texture ();
  1822.          if (Local_Texture->Constant_Flag)
  1823.             Local_Texture = Copy_Texture(Local_Texture);
  1824.  
  1825.          {
  1826.             for (temp_texture = Local_Texture ;
  1827.                         temp_texture->Next_Texture != NULL ;
  1828.                         temp_texture = temp_texture->Next_Texture)
  1829.             {}
  1830.  
  1831.             temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  1832.             Local_Shape->Shape_Texture = Local_Texture;
  1833.          }
  1834.          END_CASE
  1835.  
  1836.          CASE (COLOUR_TOKEN)
  1837.             Local_Shape->Shape_Colour = Get_Colour();
  1838.          Parse_Colour (Local_Shape->Shape_Colour);
  1839.          END_CASE
  1840.  
  1841.  
  1842.  
  1843.          OTHERWISE
  1844.          Parse_Error (RIGHT_CURLY_TOKEN);
  1845.          END_CASE
  1846.          END_EXPECT
  1847.  
  1848.          return ((SHAPE *) Local_Shape);
  1849.       }
  1850.  
  1851.       SHAPE *Parse_Plane ()
  1852.       {
  1853.          PLANE *Local_Shape;
  1854.          CONSTANT Constant_Id;
  1855.          VECTOR Local_Vector;
  1856.          TEXTURE *Local_Texture;
  1857.          TEXTURE *temp_texture;
  1858.  
  1859.          Local_Shape = NULL;
  1860.  
  1861.          GET(LEFT_CURLY_TOKEN);
  1862.  
  1863.  
  1864.          EXPECT
  1865.          CASE (LEFT_ANGLE_TOKEN)
  1866.             UNGET
  1867.             Local_Shape = Get_Plane_Shape();
  1868.          Parse_Vector(&(Local_Shape -> Normal_Vector));
  1869.          Local_Shape->Distance = Parse_Float();
  1870.          Local_Shape->Distance *= -1.0;
  1871.          EXIT
  1872.          END_CASE
  1873.  
  1874.          CASE (IDENTIFIER_TOKEN)
  1875.             if ((Constant_Id = Find_Constant()) != -1)
  1876.                if (Constants[(int)Constant_Id].Constant_Type == PLANE_CONSTANT)
  1877.                   Local_Shape = (PLANE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  1878.                else
  1879.                   Type_Error ();
  1880.             else
  1881.                Undeclared ();
  1882.          EXIT
  1883.          END_CASE
  1884.  
  1885.          OTHERWISE
  1886.          Parse_Error (LEFT_ANGLE_TOKEN);
  1887.          END_CASE
  1888.          END_EXPECT
  1889.  
  1890.          EXPECT
  1891.          CASE (RIGHT_CURLY_TOKEN)
  1892.             EXIT
  1893.             END_CASE
  1894.  
  1895.             CASE (TRANSLATE_TOKEN)
  1896.                Parse_Vector (&Local_Vector);
  1897.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  1898.          END_CASE
  1899.  
  1900.          CASE (ROTATE_TOKEN)
  1901.             Parse_Vector (&Local_Vector);
  1902.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  1903.          END_CASE
  1904.  
  1905.          CASE (SCALE_TOKEN)
  1906.             Parse_Vector (&Local_Vector);
  1907.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  1908.          END_CASE
  1909.  
  1910.          CASE (INVERSE_TOKEN)
  1911.             Invert ((OBJECT *) Local_Shape);
  1912.          END_CASE
  1913.  
  1914.          CASE (TEXTURE_TOKEN)
  1915.             Local_Texture = Parse_Texture ();
  1916.          if (Local_Texture->Constant_Flag)
  1917.             Local_Texture = Copy_Texture(Local_Texture);
  1918.  
  1919.          {
  1920.             for (temp_texture = Local_Texture ;
  1921.                         temp_texture->Next_Texture != NULL ;
  1922.                         temp_texture = temp_texture->Next_Texture)
  1923.             {}
  1924.  
  1925.             temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  1926.             Local_Shape->Shape_Texture = Local_Texture;
  1927.          }
  1928.          END_CASE
  1929.  
  1930.          CASE (COLOUR_TOKEN)
  1931.             Local_Shape->Shape_Colour = Get_Colour();
  1932.          Parse_Colour (Local_Shape->Shape_Colour);
  1933.          END_CASE
  1934.  
  1935.  
  1936.  
  1937.          OTHERWISE
  1938.          Parse_Error (RIGHT_CURLY_TOKEN);
  1939.          END_CASE
  1940.          END_EXPECT
  1941.  
  1942.          return ((SHAPE *) Local_Shape);
  1943.       }
  1944.  
  1945.       SHAPE *Parse_Height_Field ()
  1946.       {
  1947.          HEIGHT_FIELD *Local_Shape;
  1948.          CONSTANT Constant_Id;
  1949.          VECTOR Local_Vector;
  1950.          TEXTURE *Local_Texture;
  1951.          IMAGE *Image;
  1952.          int Image_Type;
  1953.  
  1954.          Local_Shape = NULL;
  1955.  
  1956.          GET(LEFT_CURLY_TOKEN);
  1957.  
  1958.          EXPECT  /* This should be modified to include other image types - CdW */
  1959.          CASE (GIF_TOKEN)
  1960.             Image_Type = GIF;
  1961.          Local_Shape = Get_Height_Field_Shape();
  1962.          if((Image = (IMAGE *) malloc(sizeof(IMAGE))) == NULL)
  1963.             Error("Out of memory. Cannot allocate space for Height Field (1st message).");
  1964.          GET(STRING_TOKEN); 
  1965.          Read_Gif_Image(Image,Token.Token_String);
  1966.          Local_Shape -> bounding_box -> bounds[0].x = 1.0;
  1967.          Local_Shape -> bounding_box -> bounds[0].y = 0.0;
  1968.          Local_Shape -> bounding_box -> bounds[0].z = 1.0;
  1969.          Local_Shape -> bounding_box -> bounds[1].x = Image -> width - 2.0;
  1970.          Local_Shape -> bounding_box -> bounds[1].y = 256.0;
  1971.          Local_Shape -> bounding_box -> bounds[1].z = Image -> height - 2.0;
  1972.          Make_Vector(&Local_Vector,1.0/(Image->width),1.0/256.0,1.0/(Image->height));
  1973.          Get_Scaling_Transformation(Local_Shape->Transformation,&Local_Vector);
  1974.          EXIT
  1975.          END_CASE
  1976.  
  1977.          CASE (POT_TOKEN)
  1978.             Image_Type = POT;
  1979.          Local_Shape = Get_Height_Field_Shape();
  1980.          if((Image = (IMAGE *) malloc(sizeof(IMAGE))) == NULL)
  1981.             Error("Out of memory. Cannot allocate space for Height Field (1st message).");
  1982.          GET(STRING_TOKEN); 
  1983.          Read_Gif_Image(Image,Token.Token_String);
  1984.          Local_Shape -> bounding_box -> bounds[0].x = 1.0;
  1985.          Local_Shape -> bounding_box -> bounds[0].y = 0.0;
  1986.          Local_Shape -> bounding_box -> bounds[0].z = 1.0;
  1987.          Local_Shape -> bounding_box -> bounds[1].x = Image -> width/2.0 - 2.0;
  1988.          Local_Shape -> bounding_box -> bounds[1].y = 256.0;
  1989.          Local_Shape -> bounding_box -> bounds[1].z = Image -> height - 2.0;
  1990.          Make_Vector(&Local_Vector,2.0/Image->width,1.0/256.0,1.0/Image->height);
  1991.          Get_Scaling_Transformation(Local_Shape->Transformation,&Local_Vector);
  1992.          EXIT
  1993.          END_CASE
  1994.  
  1995.          CASE (TGA_TOKEN)
  1996.             Image_Type = TGA;
  1997.          Local_Shape = Get_Height_Field_Shape();
  1998.          if((Image = (IMAGE *) malloc(sizeof(IMAGE))) == NULL)
  1999.             Error("Cannot allocate space for Height Field (1st message).");
  2000.          GET(STRING_TOKEN); 
  2001.          Read_Targa_Image(Image,Token.Token_String);
  2002.          Local_Shape -> bounding_box -> bounds[0].x = 1.0;
  2003.          Local_Shape -> bounding_box -> bounds[0].y = 0.0;
  2004.          Local_Shape -> bounding_box -> bounds[0].z = 1.0;
  2005.          Local_Shape -> bounding_box -> bounds[1].x = Image -> width - 2.0;
  2006.          Local_Shape -> bounding_box -> bounds[1].y = 256.0;
  2007.          Local_Shape -> bounding_box -> bounds[1].z = Image -> height - 2.0;
  2008.          Make_Vector(&Local_Vector,1.0/Image->width,1.0/256.0,1.0/Image->height);
  2009.          Get_Scaling_Transformation(Local_Shape->Transformation,&Local_Vector);  
  2010.          EXIT
  2011.          END_CASE
  2012.  
  2013.          CASE (IDENTIFIER_TOKEN)
  2014.             if ((Constant_Id = Find_Constant()) != -1)
  2015.                if (Constants[(int)Constant_Id].Constant_Type == HEIGHT_FIELD_CONSTANT)
  2016.                   Local_Shape = (HEIGHT_FIELD *)Copy((OBJECT *)Constants[(int)Constant_Id].Constant_Data);
  2017.                else
  2018.                   Type_Error ();
  2019.             else
  2020.                Undeclared ();
  2021.          EXIT
  2022.          END_CASE
  2023.  
  2024.          OTHERWISE
  2025.          Parse_Error (GIF_TOKEN);
  2026.          END_CASE
  2027.  
  2028.          END_EXPECT
  2029.  
  2030.          EXPECT
  2031.          CASE (RIGHT_CURLY_TOKEN)
  2032.             EXIT
  2033.             END_CASE
  2034.  
  2035.             CASE (WATER_LEVEL_TOKEN)
  2036.                Local_Shape -> bounding_box -> bounds[0].y = Parse_Float(); 
  2037.          END_CASE
  2038.  
  2039.          CASE (TRANSLATE_TOKEN)
  2040.             Parse_Vector (&Local_Vector);
  2041.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  2042.          END_CASE
  2043.  
  2044.          CASE (ROTATE_TOKEN)
  2045.             Parse_Vector (&Local_Vector);
  2046.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  2047.          END_CASE
  2048.  
  2049.          CASE (SCALE_TOKEN)
  2050.             Parse_Vector (&Local_Vector);
  2051.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  2052.          END_CASE
  2053.  
  2054.          CASE (INVERSE_TOKEN)
  2055.             Invert ((OBJECT *) Local_Shape);
  2056.          END_CASE
  2057.  
  2058.          CASE (TEXTURE_TOKEN)
  2059.             Local_Texture = Parse_Texture ();
  2060.          if (Local_Texture->Constant_Flag)
  2061.             Local_Texture = Copy_Texture(Local_Texture);
  2062.  
  2063.          {
  2064.             TEXTURE *temp_texture;
  2065.  
  2066.             for (temp_texture = Local_Texture ;
  2067.                         temp_texture->Next_Texture != NULL ;
  2068.                         temp_texture = temp_texture->Next_Texture)
  2069.             {}
  2070.  
  2071.             temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  2072.             Local_Shape->Shape_Texture = Local_Texture;
  2073.          }
  2074.          END_CASE
  2075.  
  2076.          CASE (COLOUR_TOKEN)
  2077.             Local_Shape->Shape_Colour = Get_Colour();
  2078.          Parse_Colour (Local_Shape->Shape_Colour);
  2079.          END_CASE
  2080.  
  2081.  
  2082.          OTHERWISE
  2083.          Parse_Error (RIGHT_CURLY_TOKEN);
  2084.          END_CASE
  2085.          END_EXPECT
  2086.  
  2087.          Find_Hf_Min_Max(Local_Shape, Image, Image_Type);
  2088.          return ((SHAPE *) Local_Shape);
  2089.       }        
  2090.  
  2091.  
  2092.       SHAPE *Parse_Triangle ()
  2093.       {
  2094.          TRIANGLE *Local_Shape;
  2095.          CONSTANT Constant_Id;
  2096.          VECTOR Local_Vector;
  2097.          TEXTURE *Local_Texture;
  2098.          TEXTURE *temp_texture;
  2099.  
  2100.          Local_Shape = NULL;
  2101.  
  2102.          GET(LEFT_CURLY_TOKEN);
  2103.  
  2104.          EXPECT
  2105.          CASE (LEFT_ANGLE_TOKEN)
  2106.             UNGET
  2107.             Local_Shape = Get_Triangle_Shape();
  2108.          Parse_Vector (&Local_Shape->P1);
  2109.          Parse_Vector (&Local_Shape->P2);
  2110.          Parse_Vector (&Local_Shape->P3);
  2111.          if (!Compute_Triangle (Local_Shape)) {
  2112.             fprintf (stderr, "Degenerate triangle on line %d.  Please remove.\n",
  2113.                Token.Token_Line_No);
  2114.             Degenerate_Triangles = TRUE;
  2115.          }
  2116.          EXIT
  2117.          END_CASE
  2118.  
  2119.          CASE (IDENTIFIER_TOKEN)
  2120.             if ((Constant_Id = Find_Constant()) != -1)
  2121.                if (Constants[(int)Constant_Id].Constant_Type == TRIANGLE_CONSTANT)
  2122.                   Local_Shape = (TRIANGLE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2123.                else
  2124.                   Type_Error ();
  2125.             else
  2126.                Undeclared ();
  2127.          EXIT
  2128.          END_CASE
  2129.  
  2130.          OTHERWISE
  2131.          Parse_Error (LEFT_ANGLE_TOKEN);
  2132.          END_CASE
  2133.          END_EXPECT
  2134.  
  2135.          EXPECT
  2136.          CASE (RIGHT_CURLY_TOKEN)
  2137.             EXIT
  2138.             END_CASE
  2139.  
  2140.             CASE (TRANSLATE_TOKEN)
  2141.                Parse_Vector (&Local_Vector);
  2142.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  2143.          END_CASE
  2144.  
  2145.          CASE (ROTATE_TOKEN)
  2146.             Parse_Vector (&Local_Vector);
  2147.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  2148.          END_CASE
  2149.  
  2150.          CASE (SCALE_TOKEN)
  2151.             Parse_Vector (&Local_Vector);
  2152.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  2153.          END_CASE
  2154.  
  2155.          CASE (INVERSE_TOKEN)
  2156.             Invert ((OBJECT *) Local_Shape);
  2157.          END_CASE
  2158.  
  2159.          CASE (TEXTURE_TOKEN)
  2160.             Local_Texture = Parse_Texture ();
  2161.          if (Local_Texture->Constant_Flag)
  2162.             Local_Texture = Copy_Texture(Local_Texture);
  2163.  
  2164.          {
  2165.             for (temp_texture = Local_Texture ;
  2166.                         temp_texture->Next_Texture != NULL ;
  2167.                         temp_texture = temp_texture->Next_Texture)
  2168.             {}
  2169.  
  2170.             temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  2171.             Local_Shape->Shape_Texture = Local_Texture;
  2172.          }
  2173.          END_CASE
  2174.  
  2175.          CASE (COLOUR_TOKEN)
  2176.             Local_Shape->Shape_Colour = Get_Colour();
  2177.          Parse_Colour (Local_Shape->Shape_Colour);
  2178.          END_CASE
  2179.  
  2180.          OTHERWISE
  2181.          Parse_Error (RIGHT_CURLY_TOKEN);
  2182.          END_CASE
  2183.          END_EXPECT
  2184.  
  2185.          return ((SHAPE *) Local_Shape);
  2186.       }
  2187.  
  2188.       SHAPE *Parse_Smooth_Triangle ()
  2189.       {
  2190.          SMOOTH_TRIANGLE *Local_Shape;
  2191.          CONSTANT Constant_Id;
  2192.          VECTOR Local_Vector;
  2193.          TEXTURE *Local_Texture;
  2194.          TEXTURE *temp_texture;
  2195.  
  2196.          Local_Shape = NULL;
  2197.  
  2198.          GET(LEFT_CURLY_TOKEN);
  2199.  
  2200.          EXPECT
  2201.          CASE (LEFT_ANGLE_TOKEN)
  2202.             UNGET
  2203.             Local_Shape = (SMOOTH_TRIANGLE *) Get_Smooth_Triangle_Shape();
  2204.          Parse_Vector (&Local_Shape->P1);
  2205.          Parse_Vector (&Local_Shape->N1);
  2206.          VNormalize (Local_Shape->N1, Local_Shape->N1)
  2207.             Parse_Vector (&Local_Shape->P2);
  2208.          Parse_Vector (&Local_Shape->N2);
  2209.          VNormalize (Local_Shape->N2, Local_Shape->N2)
  2210.             Parse_Vector (&Local_Shape->P3);
  2211.          Parse_Vector (&Local_Shape->N3);
  2212.          VNormalize (Local_Shape->N3, Local_Shape->N3)
  2213.             if (!Compute_Triangle ((TRIANGLE *) Local_Shape)) {
  2214.                fprintf (stderr, "Degenerate triangle on line %d.  Please remove.\n",
  2215.                   Token.Token_Line_No);
  2216.                Degenerate_Triangles = TRUE;
  2217.             }
  2218.          EXIT
  2219.          END_CASE
  2220.  
  2221.          CASE (IDENTIFIER_TOKEN)
  2222.             if ((Constant_Id = Find_Constant()) != -1)
  2223.                if (Constants[(int)Constant_Id].Constant_Type == SMOOTH_TRIANGLE_CONSTANT)
  2224.                   Local_Shape = (SMOOTH_TRIANGLE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2225.                else
  2226.                   Type_Error ();
  2227.             else
  2228.                Undeclared ();
  2229.          EXIT
  2230.          END_CASE
  2231.  
  2232.          OTHERWISE
  2233.          Parse_Error (LEFT_ANGLE_TOKEN);
  2234.          END_CASE
  2235.          END_EXPECT
  2236.  
  2237.          EXPECT
  2238.          CASE (RIGHT_CURLY_TOKEN)
  2239.             EXIT
  2240.             END_CASE
  2241.  
  2242.             CASE (TRANSLATE_TOKEN)
  2243.                Parse_Vector (&Local_Vector);
  2244.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  2245.          END_CASE
  2246.  
  2247.          CASE (ROTATE_TOKEN)
  2248.             Parse_Vector (&Local_Vector);
  2249.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  2250.          END_CASE
  2251.  
  2252.          CASE (SCALE_TOKEN)
  2253.             Parse_Vector (&Local_Vector);
  2254.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  2255.          END_CASE
  2256.  
  2257.          CASE (INVERSE_TOKEN)
  2258.             Invert ((OBJECT *) Local_Shape);
  2259.          END_CASE
  2260.  
  2261.          CASE (TEXTURE_TOKEN)
  2262.             Local_Texture = Parse_Texture ();
  2263.          if (Local_Texture->Constant_Flag)
  2264.             Local_Texture = Copy_Texture(Local_Texture);
  2265.  
  2266.          {
  2267.             for (temp_texture = Local_Texture ;
  2268.                         temp_texture->Next_Texture != NULL ;
  2269.                         temp_texture = temp_texture->Next_Texture)
  2270.             {}
  2271.  
  2272.             temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  2273.             Local_Shape->Shape_Texture = Local_Texture;
  2274.          }
  2275.          END_CASE
  2276.  
  2277.          CASE (COLOUR_TOKEN)
  2278.             Local_Shape->Shape_Colour = Get_Colour();
  2279.          Parse_Colour (Local_Shape->Shape_Colour);
  2280.          END_CASE
  2281.  
  2282.          OTHERWISE
  2283.          Parse_Error (RIGHT_CURLY_TOKEN);
  2284.          END_CASE
  2285.          END_EXPECT
  2286.  
  2287.          return ((SHAPE *) Local_Shape);
  2288.       }
  2289.  
  2290.       SHAPE *Parse_Quadric ()
  2291.       {
  2292.          QUADRIC *Local_Shape;
  2293.          VECTOR Local_Vector;
  2294.          CONSTANT Constant_Id;
  2295.          TEXTURE *Local_Texture;
  2296.          TEXTURE *temp_texture;
  2297.  
  2298.          Local_Shape = NULL;
  2299.  
  2300.          GET(LEFT_CURLY_TOKEN);
  2301.  
  2302.          EXPECT
  2303.          CASE (LEFT_ANGLE_TOKEN)
  2304.             UNGET
  2305.             Local_Shape = Get_Quadric_Shape();
  2306.          Parse_Vector(&(Local_Shape -> Object_2_Terms));
  2307.          Parse_Vector(&(Local_Shape -> Object_Mixed_Terms));
  2308.          Parse_Vector(&(Local_Shape -> Object_Terms));
  2309.          (Local_Shape -> Object_Constant) = Parse_Float();
  2310.          Local_Shape -> Non_Zero_Square_Term = 
  2311.          !((Local_Shape -> Object_2_Terms.x == 0.0)
  2312.             && (Local_Shape -> Object_2_Terms.y == 0.0)
  2313.             && (Local_Shape -> Object_2_Terms.z == 0.0)
  2314.             && (Local_Shape -> Object_Mixed_Terms.x == 0.0)
  2315.             && (Local_Shape -> Object_Mixed_Terms.y == 0.0)
  2316.             && (Local_Shape -> Object_Mixed_Terms.z == 0.0));
  2317.          EXIT
  2318.          END_CASE
  2319.  
  2320.          CASE (IDENTIFIER_TOKEN)
  2321.             if ((Constant_Id = Find_Constant()) != -1)
  2322.                if (Constants[(int)Constant_Id].Constant_Type == QUADRIC_CONSTANT)
  2323.                   Local_Shape = (QUADRIC *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2324.                else
  2325.                   Type_Error ();
  2326.             else
  2327.                Undeclared ();
  2328.          EXIT
  2329.          END_CASE
  2330.  
  2331.          OTHERWISE
  2332.          Parse_Error (LEFT_ANGLE_TOKEN);
  2333.          END_CASE
  2334.          END_EXPECT
  2335.  
  2336.          EXPECT
  2337.          CASE (RIGHT_CURLY_TOKEN)
  2338.             EXIT
  2339.             END_CASE
  2340.  
  2341.             CASE (TRANSLATE_TOKEN)
  2342.                Parse_Vector (&Local_Vector);
  2343.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  2344.          END_CASE
  2345.  
  2346.          CASE (ROTATE_TOKEN)
  2347.             Parse_Vector (&Local_Vector);
  2348.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  2349.          END_CASE
  2350.  
  2351.          CASE (SCALE_TOKEN)
  2352.             Parse_Vector (&Local_Vector);
  2353.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  2354.          END_CASE
  2355.  
  2356.          CASE (INVERSE_TOKEN)
  2357.             Invert ((OBJECT *) Local_Shape);
  2358.          END_CASE
  2359.  
  2360.          CASE (TEXTURE_TOKEN)
  2361.             Local_Texture = Parse_Texture ();
  2362.          if (Local_Texture->Constant_Flag)
  2363.             Local_Texture = Copy_Texture(Local_Texture);
  2364.  
  2365.          {
  2366.             for (temp_texture = Local_Texture ;
  2367.                         temp_texture->Next_Texture != NULL ;
  2368.                         temp_texture = temp_texture->Next_Texture)
  2369.             {}
  2370.  
  2371.             temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  2372.             Local_Shape->Shape_Texture = Local_Texture;
  2373.          }
  2374.          END_CASE
  2375.  
  2376.          CASE (COLOUR_TOKEN)
  2377.             Local_Shape->Shape_Colour = Get_Colour();
  2378.          Parse_Colour (Local_Shape->Shape_Colour);
  2379.          END_CASE
  2380.  
  2381.          OTHERWISE
  2382.          Parse_Error (RIGHT_CURLY_TOKEN);
  2383.          END_CASE
  2384.          END_EXPECT
  2385.  
  2386.          return ((SHAPE *) Local_Shape);
  2387.       }
  2388.  
  2389.       SHAPE *Parse_Poly (known_order)
  2390.          int known_order;
  2391.       {
  2392.          POLY *Local_Shape;
  2393.          VECTOR Local_Vector;
  2394.          CONSTANT Constant_Id;
  2395.          int order;
  2396.          TEXTURE *Local_Texture;
  2397.  
  2398.          if (known_order > 0)
  2399.             Local_Shape = Get_Poly_Shape(known_order);
  2400.          else
  2401.             Local_Shape = NULL;
  2402.  
  2403.          GET(LEFT_CURLY_TOKEN);
  2404.  
  2405.          EXPECT
  2406.          CASE3 (DASH_TOKEN, PLUS_TOKEN, FLOAT_TOKEN)
  2407.             UNGET
  2408.             if (Local_Shape != NULL)
  2409.                Error("The order of a polynomial may not be specified twice");
  2410.          order = (int)Parse_Float();
  2411.          if (order < 2 || order > MAX_ORDER)
  2412.             Error("Order of Poly is out of range");
  2413.          Local_Shape = Get_Poly_Shape(order);
  2414.          END_CASE
  2415.  
  2416.          CASE (LEFT_ANGLE_TOKEN)
  2417.             UNGET
  2418.             if (Local_Shape == NULL)
  2419.                printf("Need the order of the Poly");
  2420.          Parse_Coeffs(Local_Shape->Order, &(Local_Shape->Coeffs[0]));
  2421.          EXIT
  2422.          END_CASE
  2423.  
  2424.          CASE (IDENTIFIER_TOKEN)
  2425.             if ((Constant_Id = Find_Constant()) != -1)
  2426.                if (Constants[(int)Constant_Id].Constant_Type == POLY_CONSTANT)
  2427.                   Local_Shape = (POLY *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2428.                else
  2429.                   Type_Error ();
  2430.             else
  2431.                Undeclared ();
  2432.          EXIT
  2433.          END_CASE
  2434.  
  2435.          OTHERWISE
  2436.          Parse_Error (LEFT_ANGLE_TOKEN);
  2437.          END_CASE
  2438.          END_EXPECT
  2439.  
  2440.          EXPECT
  2441.          CASE (RIGHT_CURLY_TOKEN)
  2442.             EXIT
  2443.             END_CASE
  2444.  
  2445.             CASE (STURM_TOKEN)
  2446.                Local_Shape->Sturm_Flag = 1;
  2447.          END_CASE
  2448.  
  2449.          CASE (TRANSLATE_TOKEN)
  2450.             Parse_Vector (&Local_Vector);
  2451.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  2452.          END_CASE
  2453.  
  2454.          CASE (ROTATE_TOKEN)
  2455.             Parse_Vector (&Local_Vector);
  2456.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  2457.          END_CASE
  2458.  
  2459.          CASE (SCALE_TOKEN)
  2460.             Parse_Vector (&Local_Vector);
  2461.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  2462.          END_CASE
  2463.  
  2464.          CASE (INVERSE_TOKEN)
  2465.             Invert ((OBJECT *) Local_Shape);
  2466.          END_CASE
  2467.  
  2468.          CASE (TEXTURE_TOKEN)
  2469.             Local_Texture = Parse_Texture ();
  2470.          if (Local_Texture->Constant_Flag)
  2471.             Local_Texture = Copy_Texture(Local_Texture);
  2472.  
  2473.          Link ((OBJECT *) Local_Texture,
  2474.             (OBJECT **) &Local_Texture->Next_Texture,
  2475.             (OBJECT **) &Local_Shape->Shape_Texture);
  2476.          END_CASE
  2477.  
  2478.          CASE (COLOUR_TOKEN)
  2479.             Local_Shape->Shape_Colour = Get_Colour();
  2480.          Parse_Colour (Local_Shape->Shape_Colour);
  2481.          END_CASE
  2482.  
  2483.          OTHERWISE
  2484.          Parse_Error (RIGHT_CURLY_TOKEN);
  2485.          END_CASE
  2486.          END_EXPECT
  2487.  
  2488.          return ((SHAPE *) Local_Shape);
  2489.       }
  2490.  
  2491.       SHAPE *Parse_Bicubic_Patch ()
  2492.       {
  2493.          BICUBIC_PATCH *Local_Shape;
  2494.          VECTOR Local_Vector;
  2495.          CONSTANT Constant_Id;
  2496.          TEXTURE *Local_Texture;
  2497.          int i, j;
  2498.  
  2499.          GET(LEFT_CURLY_TOKEN);
  2500.  
  2501.          EXPECT
  2502.          CASE3 (DASH_TOKEN, PLUS_TOKEN, FLOAT_TOKEN)
  2503.             UNGET
  2504.             Local_Shape = Get_Bicubic_Patch_Shape();
  2505.          Local_Shape->Patch_Type = (int)Parse_Float();
  2506.          if (Local_Shape->Patch_Type == 2 ||
  2507.             Local_Shape->Patch_Type == 3)
  2508.             Local_Shape->Flatness_Value = Parse_Float();
  2509.          else
  2510.             Local_Shape->Flatness_Value = 0.1;
  2511.          Local_Shape->U_Steps = (int)Parse_Float();
  2512.          Local_Shape->V_Steps = (int)Parse_Float();
  2513.          for (i=0;i<4;i++) for (j=0;j<4;j++)
  2514.             Parse_Vector(&(Local_Shape -> Control_Points[i][j]));
  2515.          Precompute_Patch_Values(Local_Shape); /* interpolated mesh coords */
  2516.          EXIT
  2517.          END_CASE
  2518.  
  2519.          CASE (IDENTIFIER_TOKEN)
  2520.             if ((Constant_Id = Find_Constant()) != -1)
  2521.                if (Constants[(int)Constant_Id].Constant_Type==BICUBIC_PATCH_CONSTANT)
  2522.                   Local_Shape = (BICUBIC_PATCH *) Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2523.                else
  2524.                   Type_Error ();
  2525.             else
  2526.                Undeclared ();
  2527.          EXIT
  2528.          END_CASE
  2529.  
  2530.          OTHERWISE
  2531.          Parse_Error (LEFT_ANGLE_TOKEN);
  2532.          END_CASE
  2533.          END_EXPECT
  2534.  
  2535.          EXPECT
  2536.          CASE (RIGHT_CURLY_TOKEN)
  2537.             EXIT
  2538.             END_CASE
  2539.  
  2540.             CASE (TRANSLATE_TOKEN)
  2541.                Parse_Vector (&Local_Vector);
  2542.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  2543.          END_CASE
  2544.  
  2545.          CASE (ROTATE_TOKEN)
  2546.             Parse_Vector (&Local_Vector);
  2547.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  2548.          END_CASE
  2549.  
  2550.          CASE (SCALE_TOKEN)
  2551.             Parse_Vector (&Local_Vector);
  2552.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  2553.          END_CASE
  2554.  
  2555.          CASE (INVERSE_TOKEN)
  2556.             Invert ((OBJECT *) Local_Shape);
  2557.          END_CASE
  2558.  
  2559.          CASE (TEXTURE_TOKEN)
  2560.             Local_Texture = Parse_Texture ();
  2561.          if (Local_Texture->Constant_Flag)
  2562.             Local_Texture = Copy_Texture(Local_Texture);
  2563.  
  2564.          Link ((OBJECT *) Local_Texture,
  2565.             (OBJECT **) &Local_Texture->Next_Texture,
  2566.             (OBJECT **) &Local_Shape->Shape_Texture);
  2567.          END_CASE
  2568.  
  2569.          CASE (COLOUR_TOKEN)
  2570.             Local_Shape->Shape_Colour = Get_Colour();
  2571.          Parse_Colour (Local_Shape->Shape_Colour);
  2572.          END_CASE
  2573.  
  2574.  
  2575.  
  2576.          OTHERWISE
  2577.          Parse_Error (RIGHT_CURLY_TOKEN);
  2578.          END_CASE
  2579.          END_EXPECT
  2580.  
  2581.          return ((SHAPE *) Local_Shape);
  2582.       }
  2583.  
  2584.       SHAPE *Parse_Box ()
  2585.       {
  2586.          BOX *Local_Shape;
  2587.          CONSTANT Constant_Id;
  2588.          VECTOR Local_Vector;
  2589.          TEXTURE *Local_Texture;
  2590.          TEXTURE *temp_texture;
  2591.  
  2592.          Local_Shape = NULL;
  2593.          EXPECT
  2594.          CASE (LEFT_CURLY_TOKEN)
  2595.             EXIT
  2596.             END_CASE
  2597.             OTHERWISE
  2598.             Parse_Error (LEFT_CURLY_TOKEN);
  2599.          END_CASE
  2600.          END_EXPECT
  2601.  
  2602.          EXPECT
  2603.          CASE (LEFT_ANGLE_TOKEN)
  2604.             UNGET
  2605.             Local_Shape = Get_Box_Shape();
  2606.          Parse_Vector(&(Local_Shape->bounds[0]));
  2607.          Parse_Vector(&(Local_Shape->bounds[1]));
  2608.          EXIT
  2609.          END_CASE
  2610.  
  2611.          CASE (IDENTIFIER_TOKEN)
  2612.             if ((Constant_Id = Find_Constant()) != -1)
  2613.                if (Constants[(int)Constant_Id].Constant_Type == BOX_CONSTANT)
  2614.                   Local_Shape = (BOX *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2615.                else
  2616.                   Type_Error ();
  2617.             else
  2618.                Undeclared ();
  2619.          EXIT
  2620.          END_CASE
  2621.  
  2622.          OTHERWISE
  2623.          Parse_Error (LEFT_ANGLE_TOKEN);
  2624.          END_CASE
  2625.          END_EXPECT
  2626.  
  2627.          EXPECT
  2628.          CASE (RIGHT_CURLY_TOKEN)
  2629.             EXIT
  2630.             END_CASE
  2631.  
  2632.             CASE (TRANSLATE_TOKEN)
  2633.                Parse_Vector (&Local_Vector);
  2634.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  2635.          END_CASE
  2636.  
  2637.          CASE (ROTATE_TOKEN)
  2638.             Parse_Vector (&Local_Vector);
  2639.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  2640.          END_CASE
  2641.  
  2642.          CASE (SCALE_TOKEN)
  2643.             Parse_Vector (&Local_Vector);
  2644.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  2645.          END_CASE
  2646.  
  2647.          CASE (INVERSE_TOKEN)
  2648.             Invert ((OBJECT *) Local_Shape);
  2649.          END_CASE
  2650.  
  2651.          CASE (TEXTURE_TOKEN)
  2652.             Local_Texture = Parse_Texture ();
  2653.          if (Local_Texture->Constant_Flag)
  2654.             Local_Texture = Copy_Texture(Local_Texture);
  2655.  
  2656.          {
  2657.             for (temp_texture = Local_Texture ;
  2658.                         temp_texture->Next_Texture != NULL ;
  2659.                         temp_texture = temp_texture->Next_Texture)
  2660.             {}
  2661.  
  2662.             temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  2663.             Local_Shape->Shape_Texture = Local_Texture;
  2664.          }
  2665.          END_CASE
  2666.  
  2667.          CASE (COLOUR_TOKEN)
  2668.             Local_Shape->Shape_Colour = Get_Colour();
  2669.          Parse_Colour (Local_Shape->Shape_Colour);
  2670.          END_CASE
  2671.  
  2672.          OTHERWISE
  2673.          Parse_Error (RIGHT_CURLY_TOKEN);
  2674.          END_CASE
  2675.          END_EXPECT
  2676.  
  2677.          return ((SHAPE *) Local_Shape);
  2678.       }
  2679.  
  2680.       SHAPE *Parse_Blob ()
  2681.       {
  2682.          BLOB *Local_Shape;
  2683.          CONSTANT Constant_Id;
  2684.          VECTOR Local_Vector;
  2685.          TEXTURE *Local_Texture;
  2686.          TEXTURE *temp_texture;
  2687.          DBL threshold;
  2688.          int npoints;
  2689.          blobstackptr blob_components, blob_component;
  2690.  
  2691.          Local_Shape = NULL;
  2692.          EXPECT
  2693.          CASE (LEFT_CURLY_TOKEN)
  2694.             EXIT
  2695.             END_CASE
  2696.             OTHERWISE
  2697.             Parse_Error (LEFT_CURLY_TOKEN);
  2698.          END_CASE
  2699.          END_EXPECT
  2700.  
  2701.          EXPECT
  2702.          CASE2 (THRESHOLD_TOKEN, COMPONENT_TOKEN)
  2703.             UNGET
  2704.             Local_Shape = Get_Blob_Shape();
  2705.          blob_components = NULL;
  2706.          npoints = 0;
  2707.          threshold = 1.0;
  2708.  
  2709.          /* Here is where we get the blob coefficients */
  2710.          EXPECT
  2711.          CASE (THRESHOLD_TOKEN)
  2712.             threshold = Parse_Float();
  2713.          END_CASE
  2714.  
  2715.          CASE (COMPONENT_TOKEN)
  2716.             blob_component = (blobstackptr) malloc(sizeof(struct
  2717.                blob_list_struct));
  2718.          if (blob_component == NULL)
  2719.             Error("Out of Memory! Cannot allocate blob component");
  2720.          blob_component->elem.coeffs[2] = Parse_Float();
  2721.          blob_component->elem.radius2   = Parse_Float();
  2722.          Parse_Vector(&blob_component->elem.pos);
  2723.          blob_component->next = blob_components;
  2724.          blob_components = blob_component;
  2725.          npoints++;
  2726.          END_CASE
  2727.  
  2728.          OTHERWISE
  2729.          UNGET
  2730.          EXIT
  2731.          END_CASE
  2732.          END_EXPECT
  2733.  
  2734.          /* Finally, process the information */
  2735.          MakeBlob((OBJECT *)Local_Shape, threshold, blob_components, npoints, 0);
  2736.          EXIT
  2737.          END_CASE
  2738.  
  2739.          CASE (IDENTIFIER_TOKEN)
  2740.             if ((Constant_Id = Find_Constant()) != -1)
  2741.                if (Constants[(int)Constant_Id].Constant_Type == BLOB_CONSTANT)
  2742.                   Local_Shape = (BLOB *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2743.                else
  2744.                   Type_Error ();
  2745.             else
  2746.                Undeclared ();
  2747.          EXIT
  2748.          END_CASE
  2749.  
  2750.          OTHERWISE
  2751.          Parse_Error (FLOAT_TOKEN);
  2752.          END_CASE
  2753.          END_EXPECT
  2754.  
  2755.          EXPECT
  2756.          CASE (RIGHT_CURLY_TOKEN)
  2757.             EXIT
  2758.             END_CASE
  2759.  
  2760.             CASE (STURM_TOKEN)
  2761.                Local_Shape->Sturm_Flag = 1;
  2762.          END_CASE
  2763.  
  2764.          CASE (TRANSLATE_TOKEN)
  2765.             Parse_Vector (&Local_Vector);
  2766.          Translate ((OBJECT *) Local_Shape, &Local_Vector);
  2767.          END_CASE
  2768.  
  2769.          CASE (ROTATE_TOKEN)
  2770.             Parse_Vector (&Local_Vector);
  2771.          Rotate ((OBJECT *) Local_Shape, &Local_Vector);
  2772.          END_CASE
  2773.  
  2774.          CASE (SCALE_TOKEN)
  2775.             Parse_Vector (&Local_Vector);
  2776.          Scale ((OBJECT *) Local_Shape, &Local_Vector);
  2777.          END_CASE
  2778.  
  2779.          CASE (INVERSE_TOKEN)
  2780.             Invert ((OBJECT *) Local_Shape);
  2781.          END_CASE
  2782.  
  2783.          CASE (TEXTURE_TOKEN)
  2784.             Local_Texture = Parse_Texture ();
  2785.          if (Local_Texture->Constant_Flag)
  2786.             Local_Texture = Copy_Texture(Local_Texture);
  2787.  
  2788.          {
  2789.             for (temp_texture = Local_Texture ;
  2790.                         temp_texture->Next_Texture != NULL ;
  2791.                         temp_texture = temp_texture->Next_Texture)
  2792.             {}
  2793.  
  2794.             temp_texture->Next_Texture = Local_Shape->Shape_Texture;
  2795.             Local_Shape->Shape_Texture = Local_Texture;
  2796.          }
  2797.          END_CASE
  2798.  
  2799.          CASE (COLOUR_TOKEN)
  2800.             Local_Shape->Shape_Colour = Get_Colour();
  2801.          Parse_Colour (Local_Shape->Shape_Colour);
  2802.          END_CASE
  2803.  
  2804.          OTHERWISE
  2805.          Parse_Error (RIGHT_CURLY_TOKEN);
  2806.          END_CASE
  2807.          END_EXPECT
  2808.  
  2809.          return ((SHAPE *) Local_Shape);
  2810.       }
  2811.  
  2812.  
  2813.       CSG_SHAPE *Parse_CSG (type, Parent_Object)
  2814.          int type;
  2815.       OBJECT *Parent_Object;
  2816.       {
  2817.          CSG_SHAPE *Container = NULL;
  2818.          SHAPE *Local_Shape;
  2819.          VECTOR Local_Vector;
  2820.          CONSTANT Constant_Id;
  2821.          int First_Shape_Parsed = FALSE;
  2822.  
  2823.          if (type == CSG_UNION_TYPE)
  2824.             Container = Get_CSG_Union ();
  2825.  
  2826.          else if ((type == CSG_INTERSECTION_TYPE) || (type == CSG_DIFFERENCE_TYPE))
  2827.             Container = Get_CSG_Intersection ();
  2828.  
  2829.          Container -> Parent_Object = Parent_Object;
  2830.  
  2831.          GET(LEFT_CURLY_TOKEN);
  2832.  
  2833.          EXPECT
  2834.          CASE (IDENTIFIER_TOKEN)
  2835.             if ((Constant_Id = Find_Constant()) != -1)
  2836.                if ((Constants[(int)Constant_Id].Constant_Type == CSG_INTERSECTION_CONSTANT)
  2837.                   || (Constants[(int)Constant_Id].Constant_Type == CSG_UNION_CONSTANT)
  2838.                   || (Constants[(int)Constant_Id].Constant_Type == CSG_DIFFERENCE_CONSTANT)) {
  2839.                   free (Container);
  2840.                   Container = (CSG_SHAPE *) Copy ((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  2841.                   Set_CSG_Parents(Container, Parent_Object);
  2842.                }
  2843.                else
  2844.                   Type_Error ();
  2845.             else
  2846.                Undeclared ();
  2847.          END_CASE          
  2848.  
  2849.          CASE (LIGHT_SOURCE_TOKEN)
  2850.             Local_Shape = Parse_Light_Source ();
  2851.          Local_Shape -> Parent_Object = Parent_Object;
  2852.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2853.             Invert ((OBJECT *) Local_Shape);
  2854.          First_Shape_Parsed = TRUE;
  2855.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2856.             (OBJECT **) &(Container -> Shapes));
  2857.          END_CASE
  2858.  
  2859.          CASE (SPHERE_TOKEN)
  2860.             Local_Shape = Parse_Sphere ();
  2861.          Local_Shape -> Parent_Object = Parent_Object;
  2862.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2863.             Invert ((OBJECT *) Local_Shape);
  2864.          First_Shape_Parsed = TRUE;
  2865.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2866.             (OBJECT **) &(Container -> Shapes));
  2867.          END_CASE
  2868.  
  2869.          CASE (PLANE_TOKEN)
  2870.             Local_Shape = Parse_Plane ();
  2871.          Local_Shape -> Parent_Object = Parent_Object;
  2872.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2873.             Invert ((OBJECT *) Local_Shape);
  2874.          First_Shape_Parsed = TRUE;
  2875.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2876.             (OBJECT **) &(Container -> Shapes));
  2877.          END_CASE
  2878.  
  2879.          CASE (TRIANGLE_TOKEN)
  2880.             Local_Shape = Parse_Triangle ();
  2881.          Local_Shape -> Parent_Object = Parent_Object;
  2882.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2883.             Invert ((OBJECT *) Local_Shape);
  2884.          First_Shape_Parsed = TRUE;
  2885.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2886.             (OBJECT **) &(Container -> Shapes));
  2887.          END_CASE
  2888.  
  2889.          CASE (SMOOTH_TRIANGLE_TOKEN)
  2890.             Local_Shape = Parse_Smooth_Triangle ();
  2891.          Local_Shape -> Parent_Object = Parent_Object;
  2892.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2893.             Invert ((OBJECT *) Local_Shape);
  2894.          First_Shape_Parsed = TRUE;
  2895.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2896.             (OBJECT **) &(Container -> Shapes));
  2897.          END_CASE
  2898.  
  2899.          CASE (QUADRIC_TOKEN)
  2900.             Local_Shape = Parse_Quadric ();
  2901.          Local_Shape -> Parent_Object = Parent_Object;
  2902.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2903.             Invert ((OBJECT *) Local_Shape);
  2904.          First_Shape_Parsed = TRUE;
  2905.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2906.             (OBJECT **) &(Container -> Shapes));
  2907.          END_CASE
  2908.  
  2909.          CASE (HEIGHT_FIELD_TOKEN)
  2910.             Local_Shape = Parse_Height_Field ();
  2911.          Local_Shape -> Parent_Object = Parent_Object;
  2912.          if((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2913.             Invert((OBJECT *) Local_Shape);
  2914.          First_Shape_Parsed = TRUE;
  2915.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape-> Next_Object),
  2916.             (OBJECT **) &(Container -> Shapes));
  2917.          END_CASE
  2918.  
  2919.  
  2920.          CASE (CUBIC_TOKEN)
  2921.             Local_Shape = Parse_Poly (3);
  2922.          Local_Shape -> Parent_Object = Parent_Object;
  2923.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2924.             Invert ((OBJECT *) Local_Shape);
  2925.          First_Shape_Parsed = TRUE;
  2926.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2927.             (OBJECT **) &(Container -> Shapes));
  2928.          END_CASE
  2929.  
  2930.          CASE (QUARTIC_TOKEN)
  2931.             Local_Shape = Parse_Poly (4);
  2932.          Local_Shape -> Parent_Object = Parent_Object;
  2933.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2934.             Invert ((OBJECT *) Local_Shape);
  2935.          First_Shape_Parsed = TRUE;
  2936.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2937.             (OBJECT **) &(Container -> Shapes));
  2938.          END_CASE
  2939.  
  2940.          CASE (POLY_TOKEN)
  2941.             Local_Shape = Parse_Poly (0);
  2942.          Local_Shape -> Parent_Object = Parent_Object;
  2943.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2944.             Invert ((OBJECT *) Local_Shape);
  2945.          First_Shape_Parsed = TRUE;
  2946.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2947.             (OBJECT **) &(Container -> Shapes));
  2948.          END_CASE
  2949.  
  2950.          CASE (BOX_TOKEN)
  2951.             Local_Shape = Parse_Box ();
  2952.          Local_Shape -> Parent_Object = Parent_Object;
  2953.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2954.             Invert ((OBJECT *) Local_Shape);
  2955.          First_Shape_Parsed = TRUE;
  2956.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2957.             (OBJECT **) &(Container -> Shapes));
  2958.          END_CASE
  2959.  
  2960.          CASE (BLOB_TOKEN)
  2961.             Local_Shape = Parse_Blob ();
  2962.          Local_Shape -> Parent_Object = Parent_Object;
  2963.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2964.             Invert ((OBJECT *) Local_Shape);
  2965.          First_Shape_Parsed = TRUE;
  2966.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2967.             (OBJECT **) &(Container -> Shapes));
  2968.          END_CASE
  2969.  
  2970.          CASE (BICUBIC_PATCH_TOKEN)
  2971.             Local_Shape = Parse_Bicubic_Patch ();
  2972.          Local_Shape -> Parent_Object = Parent_Object;
  2973.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2974.             Invert ((OBJECT *) Local_Shape);
  2975.          First_Shape_Parsed = TRUE;
  2976.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2977.             (OBJECT **) &(Container -> Shapes));
  2978.          END_CASE
  2979.  
  2980.          CASE (UNION_TOKEN)
  2981.             Local_Shape = (SHAPE *) Parse_CSG (CSG_UNION_TYPE, Parent_Object);
  2982.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2983.             Invert ((OBJECT *) Local_Shape);
  2984.          First_Shape_Parsed = TRUE;
  2985.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2986.             (OBJECT **) &(Container -> Shapes));
  2987.          END_CASE
  2988.  
  2989.          CASE (INTERSECTION_TOKEN)
  2990.             Local_Shape = (SHAPE *) Parse_CSG (CSG_INTERSECTION_TYPE, Parent_Object);
  2991.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  2992.             Invert ((OBJECT *) Local_Shape);
  2993.          First_Shape_Parsed = TRUE;
  2994.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  2995.             (OBJECT **) &(Container -> Shapes));
  2996.          END_CASE
  2997.  
  2998.          CASE (DIFFERENCE_TOKEN)
  2999.             Local_Shape = (SHAPE *) Parse_CSG (CSG_DIFFERENCE_TYPE, Parent_Object);
  3000.          if ((type == CSG_DIFFERENCE_TYPE) && First_Shape_Parsed)
  3001.             Invert ((OBJECT *) Local_Shape);
  3002.          First_Shape_Parsed = TRUE;
  3003.          Link((OBJECT *) Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  3004.             (OBJECT **) &(Container -> Shapes));
  3005.          END_CASE
  3006.  
  3007.          OTHERWISE
  3008.          UNGET
  3009.          EXIT
  3010.          END_CASE
  3011.          END_EXPECT
  3012.  
  3013.          EXPECT
  3014.          CASE (RIGHT_CURLY_TOKEN)
  3015.             EXIT
  3016.             END_CASE
  3017.  
  3018.             CASE (TRANSLATE_TOKEN)
  3019.                Parse_Vector (&Local_Vector);
  3020.          Translate((OBJECT *) Container, &Local_Vector);
  3021.          END_CASE
  3022.  
  3023.          CASE (ROTATE_TOKEN)
  3024.             Parse_Vector (&Local_Vector);
  3025.          Rotate ((OBJECT *) Container, &Local_Vector);
  3026.          END_CASE
  3027.  
  3028.          CASE (SCALE_TOKEN)
  3029.             Parse_Vector (&Local_Vector);
  3030.          Scale ((OBJECT *) Container, &Local_Vector);
  3031.          END_CASE
  3032.  
  3033.          CASE (INVERSE_TOKEN)
  3034.             Invert ((OBJECT *) Container);
  3035.          END_CASE
  3036.  
  3037.          OTHERWISE
  3038.          if (type == CSG_UNION_TYPE)
  3039.             Parse_Error (RIGHT_CURLY_TOKEN);
  3040.          else if (type == CSG_INTERSECTION_TYPE)
  3041.             Parse_Error (RIGHT_CURLY_TOKEN);
  3042.          else
  3043.             Parse_Error (RIGHT_CURLY_TOKEN);
  3044.          END_CASE
  3045.          END_EXPECT
  3046.  
  3047.          return ((CSG_SHAPE *) Container);
  3048.       }
  3049.  
  3050.       SHAPE *Parse_Shape (Object)
  3051.          OBJECT *Object;
  3052.       {
  3053.          SHAPE *Local_Shape = NULL;
  3054.  
  3055.          EXPECT
  3056.          CASE (LIGHT_SOURCE_TOKEN)
  3057.             Local_Shape = Parse_Light_Source ();
  3058.          Local_Shape -> Parent_Object = Object;
  3059.          EXIT
  3060.          END_CASE
  3061.  
  3062.  
  3063.          CASE (SPHERE_TOKEN)
  3064.             Local_Shape = Parse_Sphere ();
  3065.          Local_Shape -> Parent_Object = Object;
  3066.          EXIT
  3067.          END_CASE
  3068.  
  3069.          CASE (PLANE_TOKEN)
  3070.             Local_Shape = Parse_Plane ();
  3071.          Local_Shape -> Parent_Object = Object;
  3072.          EXIT
  3073.          END_CASE
  3074.  
  3075.          CASE (TRIANGLE_TOKEN)
  3076.             Local_Shape = Parse_Triangle ();
  3077.          Local_Shape -> Parent_Object = Object;
  3078.          EXIT
  3079.          END_CASE
  3080.  
  3081.          CASE (SMOOTH_TRIANGLE_TOKEN)
  3082.             Local_Shape = Parse_Smooth_Triangle ();
  3083.          Local_Shape -> Parent_Object = Object;
  3084.          EXIT
  3085.          END_CASE
  3086.  
  3087.          CASE (QUADRIC_TOKEN)
  3088.             Local_Shape = Parse_Quadric ();
  3089.          Local_Shape -> Parent_Object = Object;
  3090.          EXIT
  3091.          END_CASE
  3092.  
  3093.          CASE (HEIGHT_FIELD_TOKEN)
  3094.             Local_Shape = Parse_Height_Field ();
  3095.          Local_Shape -> Parent_Object = Object;
  3096.          EXIT
  3097.          END_CASE
  3098.  
  3099.          CASE (CUBIC_TOKEN)
  3100.             Local_Shape = Parse_Poly (3);
  3101.          Local_Shape -> Parent_Object = Object;
  3102.          EXIT
  3103.          END_CASE
  3104.  
  3105.          CASE (QUARTIC_TOKEN)
  3106.             Local_Shape = Parse_Poly (4);
  3107.          Local_Shape -> Parent_Object = Object;
  3108.          EXIT
  3109.          END_CASE
  3110.  
  3111.          CASE (POLY_TOKEN)
  3112.             Local_Shape = Parse_Poly (0);
  3113.          Local_Shape -> Parent_Object = Object;
  3114.          EXIT
  3115.          END_CASE
  3116.  
  3117.          CASE (BOX_TOKEN)
  3118.             Local_Shape = Parse_Box ();
  3119.          Local_Shape -> Parent_Object = Object;
  3120.          EXIT
  3121.          END_CASE
  3122.  
  3123.          CASE (BLOB_TOKEN)
  3124.             Local_Shape = Parse_Blob ();
  3125.          Local_Shape -> Parent_Object = Object;
  3126.          EXIT
  3127.          END_CASE
  3128.  
  3129.          CASE (BICUBIC_PATCH_TOKEN)
  3130.             Local_Shape = Parse_Bicubic_Patch ();
  3131.          Local_Shape -> Parent_Object = Object;
  3132.          EXIT
  3133.          END_CASE
  3134.  
  3135.          CASE (UNION_TOKEN)
  3136.             Local_Shape = (SHAPE *) Parse_CSG (CSG_UNION_TYPE, Object);
  3137.          EXIT
  3138.          END_CASE
  3139.  
  3140.          CASE (INTERSECTION_TOKEN)
  3141.             Local_Shape = (SHAPE *) Parse_CSG (CSG_INTERSECTION_TYPE, Object);
  3142.          EXIT
  3143.          END_CASE
  3144.  
  3145.          CASE (DIFFERENCE_TOKEN)
  3146.             Local_Shape = (SHAPE *) Parse_CSG (CSG_DIFFERENCE_TYPE, Object);
  3147.          EXIT
  3148.          END_CASE
  3149.  
  3150.          OTHERWISE
  3151.          Parse_Error (QUADRIC_TOKEN);
  3152.          END_CASE
  3153.          END_EXPECT
  3154.          return (Local_Shape);
  3155.       }
  3156.  
  3157.       OBJECT *Parse_Object ()
  3158.       {
  3159.          OBJECT *Object;
  3160.          SHAPE *Local_Shape;
  3161.          VECTOR Local_Vector;
  3162.          CONSTANT Constant_Id;
  3163.          TEXTURE *Local_Texture;
  3164.          TEXTURE *temp_texture;
  3165.  
  3166.          Object = NULL;
  3167.  
  3168.          GET(LEFT_CURLY_TOKEN);
  3169.  
  3170.          EXPECT
  3171.          CASE (IDENTIFIER_TOKEN)
  3172.             if ((Constant_Id = Find_Constant()) != -1)
  3173.                if (Constants[(int)Constant_Id].Constant_Type == OBJECT_CONSTANT)
  3174.                   Object = (OBJECT *) Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  3175.                else
  3176.                   Type_Error ();
  3177.             else
  3178.                Undeclared ();
  3179.          EXIT
  3180.          END_CASE
  3181.  
  3182.          CASE6 (SPHERE_TOKEN, QUADRIC_TOKEN, QUARTIC_TOKEN, UNION_TOKEN,
  3183.             INTERSECTION_TOKEN, DIFFERENCE_TOKEN)
  3184.             CASE6 (TRIANGLE_TOKEN, SMOOTH_TRIANGLE_TOKEN, PLANE_TOKEN, CUBIC_TOKEN,
  3185.                POLY_TOKEN, BICUBIC_PATCH_TOKEN)
  3186.                CASE4  (HEIGHT_FIELD_TOKEN, LIGHT_SOURCE_TOKEN, BOX_TOKEN, BLOB_TOKEN)
  3187.                   UNGET
  3188.                   if (Object == NULL)
  3189.                      Object = Get_Object();
  3190.  
  3191.          Local_Shape = Parse_Shape(Object);
  3192.          Link((OBJECT *)Local_Shape, (OBJECT **) &(Local_Shape -> Next_Object),
  3193.             (OBJECT **) &(Object -> Shape));
  3194.          EXIT
  3195.          END_CASE
  3196.  
  3197.          OTHERWISE
  3198.          Parse_Error (SHAPE_TOKEN);
  3199.          EXIT
  3200.          END_CASE
  3201.          END_EXPECT
  3202.  
  3203.          EXPECT
  3204.          CASE (BOUNDED_TOKEN)
  3205.  
  3206.             GET(LEFT_CURLY_TOKEN);
  3207.  
  3208.          EXPECT
  3209.          CASE (RIGHT_CURLY_TOKEN)
  3210.             EXIT
  3211.             END_CASE
  3212.  
  3213.             OTHERWISE
  3214.             UNGET
  3215.             Local_Shape = Parse_Shape(Object);
  3216.          Link((OBJECT *) Local_Shape,
  3217.             (OBJECT **) &(Local_Shape -> Next_Object),
  3218.             (OBJECT **) &(Object -> Bounding_Shapes));
  3219.          END_CASE
  3220.          END_EXPECT       
  3221.          END_CASE
  3222.  
  3223.          CASE (CLIPPED_TOKEN)
  3224.  
  3225.             GET(LEFT_CURLY_TOKEN);
  3226.  
  3227.          EXPECT
  3228.          CASE (RIGHT_CURLY_TOKEN)
  3229.             EXIT
  3230.             END_CASE
  3231.  
  3232.             OTHERWISE
  3233.             UNGET
  3234.             Local_Shape = Parse_Shape(Object);
  3235.          Link((OBJECT *) Local_Shape,
  3236.             (OBJECT **) &(Local_Shape -> Next_Object),
  3237.             (OBJECT **) &(Object -> Clipping_Shapes));
  3238.          END_CASE
  3239.          END_EXPECT       
  3240.          END_CASE
  3241.  
  3242.          CASE (COLOUR_TOKEN)
  3243.             Object->Object_Colour = Get_Colour();
  3244.          Parse_Colour (Object -> Object_Colour);
  3245.          END_CASE
  3246.  
  3247.          CASE (TEXTURE_TOKEN)
  3248.             Local_Texture = Parse_Texture ();
  3249.          if (Local_Texture->Constant_Flag)
  3250.             Local_Texture = Copy_Texture(Local_Texture);
  3251.  
  3252.          if (Object->Object_Texture == Default_Texture)
  3253.             Object->Object_Texture = Local_Texture;
  3254.          else
  3255.          {
  3256.             for (temp_texture = Local_Texture ;
  3257.                         temp_texture->Next_Texture != NULL ;
  3258.                         temp_texture = temp_texture->Next_Texture)
  3259.             {}
  3260.  
  3261.             temp_texture->Next_Texture = Object->Object_Texture;
  3262.             Object->Object_Texture = Local_Texture;
  3263.          }
  3264.          END_CASE
  3265.  
  3266.          CASE (NO_SHADOW_TOKEN)
  3267.             Object -> No_Shadow_Flag = TRUE;
  3268.          END_CASE
  3269.  
  3270.          CASE (LIGHT_SOURCE_TOKEN)
  3271.             Error("Light source must be defined using new syntax");
  3272.          END_CASE
  3273.  
  3274.          CASE (TRANSLATE_TOKEN)
  3275.             Parse_Vector (&Local_Vector);
  3276.          Translate (Object, &Local_Vector);
  3277.          END_CASE
  3278.  
  3279.          CASE (ROTATE_TOKEN)
  3280.             Parse_Vector (&Local_Vector);
  3281.          Rotate (Object, &Local_Vector);
  3282.          END_CASE
  3283.  
  3284.          CASE (SCALE_TOKEN)
  3285.             Parse_Vector (&Local_Vector);
  3286.          Scale (Object, &Local_Vector);
  3287.          END_CASE
  3288.  
  3289.          CASE (INVERSE_TOKEN)
  3290.             Invert (Object);
  3291.          END_CASE
  3292.  
  3293.          CASE (RIGHT_CURLY_TOKEN)
  3294.             EXIT
  3295.             END_CASE
  3296.  
  3297.             OTHERWISE
  3298.             Parse_Error (RIGHT_CURLY_TOKEN);
  3299.          END_CASE
  3300.  
  3301.          END_EXPECT
  3302.  
  3303.          return (Object);
  3304.       }
  3305.  
  3306.       OBJECT *Parse_Composite ()
  3307.       {
  3308.          COMPOSITE *Local_Composite;
  3309.          OBJECT *Local_Object;
  3310.          SHAPE *Local_Shape;
  3311.          CONSTANT Constant_Id;
  3312.          VECTOR Local_Vector;
  3313.  
  3314.          Local_Composite = NULL;
  3315.  
  3316.          GET(LEFT_CURLY_TOKEN);
  3317.  
  3318.          EXPECT
  3319.          CASE (IDENTIFIER_TOKEN)
  3320.             if ((Constant_Id = Find_Constant()) != -1)
  3321.                if (Constants[(int)Constant_Id].Constant_Type == COMPOSITE_CONSTANT)
  3322.                   Local_Composite = (COMPOSITE *)Copy((OBJECT *) Constants[(int)Constant_Id].Constant_Data);
  3323.                else          
  3324.                   Type_Error ();
  3325.             else
  3326.                Undeclared ();
  3327.          END_CASE
  3328.  
  3329.          CASE (COMPOSITE_TOKEN)
  3330.             if (Local_Composite == NULL)       
  3331.                Local_Composite = Get_Composite_Object();
  3332.  
  3333.          Local_Object = Parse_Composite();
  3334.          Link((OBJECT *) Local_Object,(OBJECT **) &(Local_Object -> Next_Object),
  3335.             (OBJECT **) &(Local_Composite -> Objects));
  3336.          END_CASE
  3337.  
  3338.          CASE (OBJECT_TOKEN)
  3339.             if (Local_Composite == NULL)       
  3340.                Local_Composite = Get_Composite_Object();
  3341.  
  3342.          Local_Object = Parse_Object();
  3343.          Link(Local_Object, &(Local_Object -> Next_Object),
  3344.             &(Local_Composite -> Objects));
  3345.          END_CASE
  3346.  
  3347.          CASE (RIGHT_CURLY_TOKEN)
  3348.             UNGET
  3349.             if (Local_Composite == NULL)       
  3350.                Local_Composite = Get_Composite_Object();
  3351.  
  3352.          EXIT
  3353.          END_CASE
  3354.  
  3355.          OTHERWISE
  3356.          UNGET
  3357.          EXIT
  3358.          END_CASE
  3359.          END_EXPECT
  3360.  
  3361.          EXPECT
  3362.          CASE (RIGHT_CURLY_TOKEN)
  3363.             EXIT
  3364.             END_CASE
  3365.  
  3366.             CASE (BOUNDED_TOKEN)
  3367.  
  3368.                GET(LEFT_CURLY_TOKEN);
  3369.  
  3370.          EXPECT
  3371.          CASE (RIGHT_CURLY_TOKEN)
  3372.             EXIT
  3373.             END_CASE
  3374.  
  3375.             OTHERWISE
  3376.             UNGET
  3377.             Local_Shape = Parse_Shape((OBJECT *) Local_Composite);
  3378.          Link((OBJECT *) Local_Shape,
  3379.             (OBJECT **) &(Local_Shape -> Next_Object),
  3380.             (OBJECT **) &(Local_Composite -> Bounding_Shapes));
  3381.          END_CASE
  3382.          END_EXPECT       
  3383.          END_CASE
  3384.  
  3385.          CASE (CLIPPED_TOKEN)
  3386.  
  3387.             GET(LEFT_CURLY_TOKEN);
  3388.  
  3389.          EXPECT
  3390.          CASE (RIGHT_CURLY_TOKEN)
  3391.             EXIT
  3392.             END_CASE
  3393.  
  3394.             OTHERWISE
  3395.             UNGET
  3396.             Local_Shape = Parse_Shape((OBJECT *) Local_Composite);
  3397.          Link((OBJECT *) Local_Shape,
  3398.             (OBJECT **) &(Local_Shape -> Next_Object),
  3399.             (OBJECT **) &(Local_Composite -> Clipping_Shapes));
  3400.          END_CASE
  3401.          END_EXPECT       
  3402.          END_CASE
  3403.  
  3404.          CASE (TRANSLATE_TOKEN)
  3405.             Parse_Vector (&Local_Vector);
  3406.          Translate ((OBJECT *) Local_Composite, &Local_Vector);
  3407.          END_CASE
  3408.  
  3409.          CASE (ROTATE_TOKEN)
  3410.             Parse_Vector (&Local_Vector);
  3411.          Rotate ((OBJECT *) Local_Composite, &Local_Vector);
  3412.          END_CASE
  3413.  
  3414.          CASE (SCALE_TOKEN)
  3415.             Parse_Vector (&Local_Vector);
  3416.          Scale ((OBJECT *) Local_Composite, &Local_Vector);
  3417.          END_CASE
  3418.  
  3419.          CASE (INVERSE_TOKEN)
  3420.             Invert ((OBJECT *) Local_Composite);
  3421.          END_CASE
  3422.  
  3423.          OTHERWISE
  3424.          Parse_Error (RIGHT_CURLY_TOKEN);
  3425.          END_CASE
  3426.          END_EXPECT
  3427.  
  3428.          return ((OBJECT *) Local_Composite);
  3429.       }
  3430.  
  3431.       void Parse_Fog ()
  3432.       {   
  3433.  
  3434.          GET(LEFT_CURLY_TOKEN);
  3435.  
  3436.          EXPECT
  3437.          CASE (COLOUR_TOKEN)
  3438.             Parse_Colour (&Parsing_Frame_Ptr->Fog_Colour);
  3439.          END_CASE
  3440.  
  3441.          CASE (FLOAT_TOKEN)
  3442.             Parsing_Frame_Ptr->Fog_Distance = Token.Token_Float;
  3443.          END_CASE
  3444.  
  3445.          CASE (RIGHT_CURLY_TOKEN)
  3446.             EXIT
  3447.             END_CASE
  3448.  
  3449.             OTHERWISE
  3450.             Parse_Error (RIGHT_CURLY_TOKEN);
  3451.          END_CASE
  3452.          END_EXPECT
  3453.       }
  3454.  
  3455.       /*
  3456.    }
  3457. */
  3458.  
  3459.       void Parse_Frame ()
  3460.       {
  3461.          OBJECT *Local_Object;
  3462.  
  3463.          EXPECT
  3464.          CASE (FOG_TOKEN)
  3465.             Parse_Fog();
  3466.          END_CASE
  3467.  
  3468.  
  3469.          CASE (DEFAULT_TOKEN)
  3470.             GET(LEFT_CURLY_TOKEN);
  3471.          EXPECT    
  3472.          CASE (TEXTURE_TOKEN)
  3473.             Default_Texture->Constant_Flag = FALSE;
  3474.          Default_Texture = Parse_Texture ();
  3475.          Default_Texture->Constant_Flag = TRUE;
  3476.          END_CASE        
  3477.          CASE (RIGHT_CURLY_TOKEN)
  3478.             EXIT
  3479.             END_CASE
  3480.  
  3481.             OTHERWISE
  3482.             Parse_Error (RIGHT_CURLY_TOKEN);
  3483.          END_CASE
  3484.          END_EXPECT      
  3485.          END_CASE
  3486.  
  3487.  
  3488.          CASE (MAX_TRACE_LEVEL_TOKEN)
  3489.             Max_Trace_Level = Parse_Float ();
  3490.          END_CASE        
  3491.  
  3492.          CASE (OBJECT_TOKEN)
  3493.             Local_Object = Parse_Object();
  3494.          Link(Local_Object, &(Local_Object -> Next_Object),
  3495.             &(Parsing_Frame_Ptr -> Objects));
  3496.  
  3497.          /* light sources are now linked in object parsing */
  3498.          /* if (Local_Object -> Light_Source_Flag)
  3499.      Link(Local_Object, &(Local_Object -> Next_Light_Source),
  3500.            &(Parsing_Frame_Ptr -> Light_Sources)); */
  3501.          END_CASE
  3502.  
  3503.          CASE (COMPOSITE_TOKEN)
  3504.             Local_Object = Parse_Composite();
  3505.          Link(Local_Object, &(Local_Object -> Next_Object),
  3506.             &(Parsing_Frame_Ptr -> Objects));
  3507.  
  3508.          /*      Add_Composite_Light_Source ((COMPOSITE *)Local_Object);*/
  3509.          END_CASE
  3510.  
  3511.          CASE (VIEW_POINT_TOKEN)
  3512.             Parse_Viewpoint(&(Parsing_Frame_Ptr -> View_Point));
  3513.          END_CASE
  3514.  
  3515.          CASE (DECLARE_TOKEN)
  3516.             Parse_Declare ();
  3517.          END_CASE
  3518.  
  3519.          CASE (END_OF_FILE_TOKEN)
  3520.             EXIT
  3521.             END_CASE
  3522.  
  3523.             OTHERWISE 
  3524.             Parse_Error (OBJECT_TOKEN);
  3525.          END_CASE
  3526.          END_EXPECT
  3527.       }
  3528.  
  3529.       void Parse_Viewpoint (Given_Vp)
  3530.          VIEWPOINT *Given_Vp;
  3531.       {
  3532.          CONSTANT Constant_Id;
  3533.          VECTOR Local_Vector, Temp_Vector;
  3534.          DBL Direction_Length, Up_Length, Right_Length, Handedness;
  3535.  
  3536.          Init_Viewpoint (Given_Vp);
  3537.  
  3538.          GET(LEFT_CURLY_TOKEN);
  3539.  
  3540.          EXPECT
  3541.          CASE (IDENTIFIER_TOKEN)
  3542.             if ((Constant_Id = Find_Constant()) != -1)
  3543.                if (Constants[(int)Constant_Id].Constant_Type == VIEW_POINT_CONSTANT)
  3544.                   *Given_Vp = 
  3545.                   *((VIEWPOINT*) Constants[(int)Constant_Id].Constant_Data);
  3546.                else
  3547.                   Type_Error ();
  3548.             else
  3549.                Undeclared ();
  3550.          END_CASE
  3551.  
  3552.          CASE (LOCATION_TOKEN)
  3553.             Parse_Vector(&(Given_Vp -> Location));
  3554.          END_CASE
  3555.  
  3556.          CASE (DIRECTION_TOKEN)
  3557.             Parse_Vector(&(Given_Vp -> Direction));
  3558.          END_CASE
  3559.  
  3560.          CASE (UP_TOKEN)
  3561.             Parse_Vector(&(Given_Vp -> Up));
  3562.          END_CASE
  3563.  
  3564.          CASE (RIGHT_TOKEN)
  3565.             Parse_Vector(&(Given_Vp -> Right));
  3566.          END_CASE
  3567.  
  3568.          CASE (SKY_TOKEN)
  3569.             Parse_Vector(&(Given_Vp -> Sky));
  3570.          END_CASE
  3571.  
  3572.          CASE (LOOK_AT_TOKEN)
  3573.             VLength (Direction_Length, Given_Vp->Direction);
  3574.          VLength (Up_Length, Given_Vp->Up);
  3575.          VLength (Right_Length, Given_Vp->Right);
  3576.          VCross (Temp_Vector, Given_Vp->Direction, Given_Vp->Up);
  3577.          VDot (Handedness, Temp_Vector, Given_Vp->Right);
  3578.          Parse_Vector(&Given_Vp->Direction);
  3579.  
  3580.          VSub (Given_Vp->Direction, Given_Vp->Direction, Given_Vp->Location);
  3581.          VNormalize (Given_Vp->Direction, Given_Vp->Direction);
  3582.          VCross(Given_Vp->Right, Given_Vp->Direction, Given_Vp->Sky);
  3583.          VNormalize (Given_Vp->Right, Given_Vp->Right);
  3584.          VCross (Given_Vp->Up, Given_Vp->Right, Given_Vp->Direction);
  3585.          VScale (Given_Vp->Direction, Given_Vp->Direction, Direction_Length);
  3586.          if (Handedness >= 0.0) {
  3587.             VScale (Given_Vp->Right, Given_Vp->Right, Right_Length);
  3588.          }
  3589.          else {
  3590.             VScale (Given_Vp->Right, Given_Vp->Right, -Right_Length);
  3591.          }
  3592.  
  3593.             VScale (Given_Vp->Up, Given_Vp->Up, Up_Length);       
  3594.          END_CASE
  3595.  
  3596.          CASE (TRANSLATE_TOKEN)
  3597.             Parse_Vector (&Local_Vector);
  3598.          Translate ((OBJECT *) Given_Vp, &Local_Vector);
  3599.          END_CASE
  3600.  
  3601.          CASE (ROTATE_TOKEN)
  3602.             Parse_Vector (&Local_Vector);
  3603.          Rotate ((OBJECT *) Given_Vp, &Local_Vector);
  3604.          END_CASE
  3605.  
  3606.          CASE (SCALE_TOKEN)
  3607.             Parse_Vector (&Local_Vector);
  3608.          Scale ((OBJECT *) Given_Vp, &Local_Vector);
  3609.          END_CASE
  3610.  
  3611.          CASE (RIGHT_CURLY_TOKEN)
  3612.             EXIT
  3613.             END_CASE
  3614.  
  3615.             OTHERWISE
  3616.             Parse_Error (RIGHT_CURLY_TOKEN);
  3617.          END_CASE
  3618.          END_EXPECT
  3619.       }
  3620.  
  3621.       void Parse_Declare ()
  3622.       {
  3623.          CONSTANT Constant_Id;
  3624.          TEXTURE *Local_Texture;
  3625.          TEXTURE *temp_texture;
  3626.          struct Constant_Struct *Constant_Ptr;
  3627.  
  3628.          GET (IDENTIFIER_TOKEN);
  3629.          if ((Constant_Id = Find_Constant()) == -1)
  3630.             if (++Number_Of_Constants >= MAX_CONSTANTS)
  3631.                Error ("Too many constants \"declared\"");
  3632.             else
  3633.                Constant_Id = Number_Of_Constants;
  3634.  
  3635.          Constant_Ptr = &(Constants[(int)Constant_Id]);
  3636.          GET (EQUALS_TOKEN);
  3637.  
  3638.          EXPECT
  3639.          CASE (OBJECT_TOKEN)
  3640.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3641.          Constant_Ptr -> Constant_Data = (char *) Parse_Object();
  3642.          Constant_Ptr -> Constant_Type = OBJECT_CONSTANT;
  3643.          EXIT
  3644.          END_CASE
  3645.  
  3646.          CASE (SPHERE_TOKEN)
  3647.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3648.          Constant_Ptr -> Constant_Data = (char *) Parse_Sphere ();
  3649.          Constant_Ptr -> Constant_Type = SPHERE_CONSTANT;
  3650.          EXIT
  3651.          END_CASE
  3652.  
  3653.          CASE (PLANE_TOKEN)
  3654.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3655.          Constant_Ptr -> Constant_Data = (char *) Parse_Plane ();
  3656.          Constant_Ptr -> Constant_Type = PLANE_CONSTANT;
  3657.          EXIT
  3658.          END_CASE
  3659.  
  3660.          CASE (TRIANGLE_TOKEN)
  3661.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3662.          Constant_Ptr -> Constant_Data = (char *) Parse_Triangle ();
  3663.          Constant_Ptr -> Constant_Type = TRIANGLE_CONSTANT;
  3664.          EXIT
  3665.          END_CASE
  3666.  
  3667.          CASE (SMOOTH_TRIANGLE_TOKEN)
  3668.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3669.          Constant_Ptr -> Constant_Data = (char *) Parse_Smooth_Triangle ();
  3670.          Constant_Ptr -> Constant_Type = SMOOTH_TRIANGLE_CONSTANT;
  3671.          EXIT
  3672.          END_CASE
  3673.  
  3674.          CASE (QUADRIC_TOKEN)
  3675.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3676.          Constant_Ptr -> Constant_Data = (char *) Parse_Quadric ();
  3677.          Constant_Ptr -> Constant_Type = QUADRIC_CONSTANT;
  3678.          EXIT
  3679.          END_CASE
  3680.  
  3681.          CASE (CUBIC_TOKEN)
  3682.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3683.          Constant_Ptr -> Constant_Data = (char *) Parse_Poly (3);
  3684.          Constant_Ptr -> Constant_Type = POLY_CONSTANT;
  3685.          EXIT
  3686.          END_CASE
  3687.  
  3688.          CASE (QUARTIC_TOKEN)
  3689.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3690.          Constant_Ptr -> Constant_Data = (char *) Parse_Poly (4);
  3691.          Constant_Ptr -> Constant_Type = POLY_CONSTANT;
  3692.          EXIT
  3693.          END_CASE
  3694.  
  3695.          CASE (HEIGHT_FIELD_TOKEN)
  3696.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3697.          Constant_Ptr -> Constant_Data = (char *) Parse_Height_Field ();
  3698.          Constant_Ptr -> Constant_Type = HEIGHT_FIELD_CONSTANT;
  3699.          EXIT
  3700.          END_CASE
  3701.  
  3702.          CASE (POLY_TOKEN)
  3703.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3704.          Constant_Ptr -> Constant_Data = (char *) Parse_Poly (0);
  3705.          Constant_Ptr -> Constant_Type = POLY_CONSTANT;
  3706.          EXIT
  3707.          END_CASE
  3708.  
  3709.          CASE (BOX_TOKEN)
  3710.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3711.          Constant_Ptr -> Constant_Data = (char *) Parse_Box ();
  3712.          Constant_Ptr -> Constant_Type = BOX_CONSTANT;
  3713.          EXIT
  3714.          END_CASE
  3715.  
  3716.          CASE (BLOB_TOKEN)
  3717.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3718.          Constant_Ptr -> Constant_Data = (char *) Parse_Blob ();
  3719.          Constant_Ptr -> Constant_Type = BLOB_CONSTANT;
  3720.          EXIT
  3721.          END_CASE
  3722.  
  3723.          CASE (BICUBIC_PATCH_TOKEN)
  3724.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3725.          Constant_Ptr -> Constant_Data = (char *) Parse_Bicubic_Patch ();
  3726.          Constant_Ptr -> Constant_Type = BICUBIC_PATCH_CONSTANT;
  3727.          EXIT
  3728.          END_CASE
  3729.  
  3730.          CASE (INTERSECTION_TOKEN)
  3731.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3732.          Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_INTERSECTION_TYPE, NULL);
  3733.          Constant_Ptr -> Constant_Type = CSG_INTERSECTION_CONSTANT;
  3734.          EXIT
  3735.          END_CASE
  3736.  
  3737.          CASE (UNION_TOKEN)
  3738.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3739.          Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_UNION_TYPE, NULL);
  3740.          Constant_Ptr -> Constant_Type = CSG_UNION_CONSTANT;
  3741.          EXIT
  3742.          END_CASE
  3743.  
  3744.          CASE (DIFFERENCE_TOKEN)
  3745.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3746.          Constant_Ptr -> Constant_Data = (char *) Parse_CSG(CSG_DIFFERENCE_TYPE, NULL);
  3747.          Constant_Ptr -> Constant_Type = CSG_DIFFERENCE_CONSTANT;
  3748.          EXIT
  3749.          END_CASE
  3750.  
  3751.          CASE (COMPOSITE_TOKEN)
  3752.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3753.          Constant_Ptr -> Constant_Data = (char *) Parse_Composite();
  3754.          Constant_Ptr -> Constant_Type = COMPOSITE_CONSTANT;
  3755.          EXIT
  3756.          END_CASE
  3757.  
  3758.          CASE (TEXTURE_TOKEN)
  3759.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3760.          Local_Texture = NULL;
  3761.          Constant_Ptr -> Constant_Data = (char *) Local_Texture;
  3762.          Constant_Ptr -> Constant_Type = TEXTURE_CONSTANT;
  3763.          UNGET
  3764.          EXPECT
  3765.          CASE (TEXTURE_TOKEN)
  3766.             Local_Texture = Default_Texture;
  3767.          Local_Texture = Parse_Texture ();
  3768.          if (Local_Texture->Constant_Flag)
  3769.             Local_Texture = Copy_Texture(Local_Texture);
  3770.  
  3771.          Local_Texture -> Constant_Flag = TRUE;
  3772.  
  3773.          {
  3774.             for (temp_texture = Local_Texture ;
  3775.                         temp_texture->Next_Texture != NULL ;
  3776.                         temp_texture = temp_texture->Next_Texture)
  3777.             {}
  3778.  
  3779.             temp_texture->Next_Texture = (TEXTURE *) Constant_Ptr->Constant_Data;
  3780.             Constant_Ptr->Constant_Data = (char *) Local_Texture;
  3781.          }
  3782.          END_CASE
  3783.  
  3784.          OTHERWISE
  3785.          UNGET
  3786.          EXIT
  3787.          END_CASE
  3788.          END_EXPECT
  3789.          EXIT
  3790.          END_CASE
  3791.  
  3792.          CASE (VIEW_POINT_TOKEN)
  3793.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3794.          Constant_Ptr -> Constant_Data = (char *) Get_Viewpoint();
  3795.          Constant_Ptr -> Constant_Type = VIEW_POINT_CONSTANT;
  3796.          Parse_Viewpoint((VIEWPOINT *) Constant_Ptr -> Constant_Data);
  3797.          EXIT
  3798.          END_CASE
  3799.  
  3800.          CASE (COLOUR_TOKEN)
  3801.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3802.          Constant_Ptr -> Constant_Data = (char *) Get_Colour();
  3803.          Constant_Ptr -> Constant_Type = COLOUR_CONSTANT;
  3804.          Parse_Colour ((COLOUR *) Constant_Ptr -> Constant_Data);
  3805.          EXIT
  3806.          END_CASE
  3807.  
  3808.          CASE (LIGHT_SOURCE_TOKEN)
  3809.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3810.          Constant_Ptr -> Constant_Data = (char *) Parse_Light_Source ();
  3811.          Constant_Ptr -> Constant_Type = LIGHT_SOURCE_CONSTANT;
  3812.          EXIT
  3813.          END_CASE
  3814.  
  3815.  
  3816.          CASE (LEFT_ANGLE_TOKEN)
  3817.             UNGET
  3818.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3819.          Constant_Ptr -> Constant_Data = (char *) Get_Vector();
  3820.          Constant_Ptr -> Constant_Type = VECTOR_CONSTANT;
  3821.          Parse_Vector((VECTOR *) Constant_Ptr -> Constant_Data);
  3822.          EXIT
  3823.          END_CASE
  3824.  
  3825.          CASE3 (DASH_TOKEN, PLUS_TOKEN, FLOAT_TOKEN)
  3826.             UNGET
  3827.             Constant_Ptr -> Identifier_Number = Token.Identifier_Number;
  3828.          Constant_Ptr -> Constant_Data = (char *) Get_Float();
  3829.          Constant_Ptr -> Constant_Type = FLOAT_CONSTANT;
  3830.          *((DBL *) Constant_Ptr -> Constant_Data) = Parse_Float();
  3831.          EXIT
  3832.          END_CASE
  3833.  
  3834.          OTHERWISE
  3835.          Parse_Error (OBJECT_TOKEN);
  3836.          END_CASE
  3837.          END_EXPECT
  3838.       }
  3839.  
  3840.       void Init_Viewpoint (vp)
  3841.          VIEWPOINT *vp;
  3842.       {
  3843.          vp -> Methods = (void *) &Viewpoint_Methods;
  3844.          vp -> Type = VIEWPOINT_TYPE;
  3845.          Make_Vector (&vp->Location, 0.0, 0.0, 0.0);
  3846.          Make_Vector (&vp->Direction, 0.0, 0.0, 1.0);
  3847.          Make_Vector (&vp->Up, 0.0, 1.0, 0.0);
  3848.          Make_Vector (&vp->Right, 1.33, 0.0, 0.0);
  3849.          Make_Vector (&vp->Sky, 0.0, 1.0, 0.0);
  3850.       }
  3851.  
  3852.       void Link (New_Object, Field, Old_Object_List)
  3853.          OBJECT *New_Object, **Field, **Old_Object_List;
  3854.       {
  3855.          *Field = *Old_Object_List;
  3856.          *Old_Object_List = New_Object;
  3857.       }
  3858.       static void Link_Shapes (New_Object, Field, Old_Object_List)
  3859.          LIGHT_SHAPE *New_Object, **Field, **Old_Object_List;
  3860.       {
  3861.          *Field = *Old_Object_List;
  3862.          *Old_Object_List = New_Object;
  3863.       }
  3864.  
  3865.  
  3866.       CONSTANT Find_Constant()
  3867.       {
  3868.          register int i;
  3869.  
  3870.          for (i = 1 ; i <= Number_Of_Constants ; i++)
  3871.             if (Constants [i].Identifier_Number == Token.Identifier_Number)
  3872.                return (i);
  3873.  
  3874.          return (-1);
  3875.       }
  3876.  
  3877.  
  3878.       char *Get_Token_String (Token_Id)
  3879.          TOKEN Token_Id;
  3880.       {
  3881.          register int i;
  3882.  
  3883.          for (i = 0 ; i < LAST_TOKEN ; i++)
  3884.             if (Reserved_Words[i].Token_Number == Token_Id)
  3885.                return (Reserved_Words[i].Token_Name);
  3886.          return ("");
  3887.       }
  3888.  
  3889.       void Parse_Error (Token_Id)
  3890.          TOKEN Token_Id;
  3891.       {
  3892.          char *expected, *found;
  3893.          FILE *stat_file;
  3894.          fprintf (stderr, "Error in file %s line %d\n", Token.Filename,
  3895.             Token.Token_Line_No+1);
  3896.          expected = Get_Token_String (Token_Id);
  3897.          found = Get_Token_String (Token.Token_Id);
  3898.          fprintf (stderr, "%s expected but %s found instead\n", expected, found);
  3899.          if (Options & VERBOSE_FILE){
  3900.             stat_file = fopen(Stat_File_Name,"w+t");
  3901.             fprintf (stat_file, "%s expected but %s found instead\n", expected, found);
  3902.             fclose(stat_file);
  3903.          }
  3904.  
  3905.          exit(1);
  3906.       }
  3907.  
  3908.       void Type_Error ()
  3909.       {
  3910.          FILE *stat_file;
  3911.          fprintf (stderr, "Error in file %s line %d\n", Token.Filename,
  3912.             Token.Token_Line_No+1);
  3913.          fprintf (stderr, "Identifier %s is the wrong type\n", Token.Token_String);
  3914.          if (Options & VERBOSE_FILE){
  3915.             stat_file = fopen(Stat_File_Name,"w+t");
  3916.             fprintf (stat_file, "Error in file %s line %d\n", Token.Filename,
  3917.                Token.Token_Line_No+1);
  3918.             fprintf (stat_file, "Identifier %s is the wrong type\n", Token.Token_String);
  3919.  
  3920.             fclose(stat_file);
  3921.          }
  3922.  
  3923.          exit (1);
  3924.       }
  3925.  
  3926.       void Undeclared ()
  3927.       {
  3928.          FILE *stat_file;
  3929.          fprintf (stderr, "Error in file %s line %d\n", Token.Filename,
  3930.             Token.Token_Line_No+1);
  3931.          fprintf (stderr, "Undeclared identifier %s\n", Token.Token_String);
  3932.          if (Options & VERBOSE_FILE){
  3933.             stat_file = fopen(Stat_File_Name,"w+t");
  3934.             fprintf (stat_file, "Error in file %s line %d\n", Token.Filename,
  3935.                Token.Token_Line_No+1);
  3936.             fprintf (stat_file, "Undeclared identifier %s\n", Token.Token_String);
  3937.             fclose(stat_file);
  3938.          }
  3939.  
  3940.          exit (1);
  3941.       }
  3942.  
  3943.       void Error (str)
  3944.          char *str;
  3945.       {
  3946.          FILE *stat_file;
  3947.          fprintf (stderr, "Error in file %s line %d\n", Token.Filename,
  3948.             Token.Token_Line_No+1);
  3949.          fprintf (stderr,"%s\n",str);
  3950.  
  3951.          if (Options & VERBOSE_FILE){
  3952.             stat_file = fopen(Stat_File_Name,"w+t");
  3953.             fprintf (stat_file, "Error in file %s line %d\n", Token.Filename,
  3954.                Token.Token_Line_No+1);
  3955.             fprintf (stat_file,"%s\n",str);
  3956.             fclose(stat_file);
  3957.          }
  3958.          exit (1);
  3959.       }
  3960.  
  3961.       static void Post_Process_Object (Object)
  3962.          OBJECT *Object;
  3963.       {
  3964.          OBJECT *Temp;
  3965.  
  3966.          if (Object->Type == COMPOSITE_TYPE)
  3967.             for (Temp = ((COMPOSITE *)Object) -> Objects;
  3968.                      Temp != NULL ; 
  3969.                      Temp = Temp->Next_Object) 
  3970.                Post_Process_Object (Temp);
  3971.          else
  3972.             Post_Process_Shape (Object->Shape);
  3973.       }
  3974.  
  3975.       static void Post_Process_Shape (Shape)
  3976.          SHAPE *Shape;
  3977.       {
  3978.          SHAPE *Temp_Shape;
  3979.  
  3980.          if ((Shape->Type == CSG_UNION_TYPE) 
  3981.             || (Shape->Type == CSG_INTERSECTION_TYPE)
  3982.             || (Shape->Type == CSG_DIFFERENCE_TYPE))
  3983.             for (Temp_Shape = ((CSG_SHAPE *)Shape)->Shapes;
  3984.                      Temp_Shape != NULL ; 
  3985.                      Temp_Shape = Temp_Shape->Next_Object)
  3986.                Post_Process_Shape(Temp_Shape);
  3987.          else
  3988.             if ((Shape->Type == POINT_LIGHT_TYPE)
  3989.                ||(Shape->Type == SPOT_LIGHT_TYPE))
  3990.                Link_Shapes ((LIGHT_SHAPE *)Shape, 
  3991.                   &(((LIGHT_SHAPE *)Shape)->Next_Light_Source),
  3992.                   &(Parsing_Frame_Ptr -> Light_Sources));
  3993.       }
  3994.