home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / GRAPHICS / povosk.lzh / tokenize.c < prev   
Text File  |  1993-01-31  |  24KB  |  933 lines
  1. /****************************************************************************
  2. *                tokenize.c
  3. *
  4. *  This module implements the first part of a two part parser for the scene
  5. *  description files.  This phase changes the input file into tokens.
  6. *
  7. *  from Persistence of Vision Raytracer 
  8. *  Copyright 1992 Persistence of Vision Team
  9. *---------------------------------------------------------------------------
  10. *  Copying, distribution and legal info is in the file povlegal.doc which
  11. *  should be distributed with this file. If povlegal.doc is not available
  12. *  or for more info please contact:
  13. *
  14. *       Drew Wells [POV-Team Leader] 
  15. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  16. *       Phone: (213) 254-4041
  17. * 
  18. * This program is based on the popular DKB raytracer version 2.12.
  19. * DKBTrace was originally written by David K. Buck.
  20. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  21. *
  22. *****************************************************************************/
  23.  
  24. #include <ctype.h>
  25. #include "frame.h"
  26. #include "povproto.h"
  27.  
  28. /* This module tokenizes the input file and sends the tokens created
  29. to the parser (the second stage).  Tokens sent to the parser contain a
  30. token ID, the line number of the token, and if necessary, some data for
  31. the token.  */
  32.  
  33. #define MAX_STRING_INDEX 41
  34. char String[MAX_STRING_INDEX];
  35. int String_Index;
  36. extern char Library_Path[];
  37. extern int Stop_Flag;
  38. static int pov_stricmp PARAMS ((char *s1,char *s2));
  39.  
  40. /* Here are the reserved words.  If you need to add new words, be sure
  41. to declare them in frame.h */
  42.  
  43. struct Reserved_Word_Struct Reserved_Words [LAST_TOKEN] = {
  44.    AGATE_TOKEN, "agate",
  45.    ALL_TOKEN, "all",
  46.    ALPHA_TOKEN, "alpha",
  47.    AMBIENT_TOKEN, "ambient",
  48.    AMPERSAND_TOKEN, "&",
  49.    AT_TOKEN, "@",
  50.    BACK_QUOTE_TOKEN, "`",
  51.    BACK_SLASH_TOKEN, "\\",
  52.    BAR_TOKEN, "|",
  53.    BICUBIC_PATCH_TOKEN, "bicubic_patch",
  54.    BLUE_TOKEN, "blue",
  55.    BRICK_TOKEN, "brick",
  56.    BRILLIANCE_TOKEN, "brilliance",
  57.    BLOB_TOKEN, "blob",
  58.    BOX_TOKEN, "box",
  59.    BOZO_TOKEN, "bozo",
  60.    BOUNDED_TOKEN, "bounded_by",
  61.    BUMPS_TOKEN, "bumps",
  62.    BUMPSIZE_TOKEN, "bump_size",
  63.    BUMPMAP_TOKEN, "bump_map",
  64.    BUMPY1_TOKEN, "bumpy1",
  65.    BUMPY2_TOKEN, "bumpy2",
  66.    BUMPY3_TOKEN, "bumpy3",  
  67.    CENTER_TOKEN, "center",
  68.    CHECKER_TOKEN, "checker",
  69.    CHECKER_TEXTURE_TOKEN, "tiles",
  70.    CLIPPED_TOKEN, "clipped_by",
  71.    COLON_TOKEN, ":",
  72.    COLOUR_TOKEN, "color",
  73.    COLOUR_TOKEN, "colour",
  74.    COLOUR_MAP_TOKEN, "color_map",
  75.    COLOUR_MAP_TOKEN, "colour_map",
  76.    COMMA_TOKEN, ",",
  77.    COMPONENT_TOKEN, "component",
  78.    COMPOSITE_TOKEN, "composite",
  79.    CONCENTRATION_TOKEN, "concentration",
  80.    CUBIC_TOKEN, "cubic",
  81.    DASH_TOKEN, "-",
  82.    DECLARE_TOKEN, "declare",
  83.    DEFAULT_TOKEN, "default",
  84.    DENTS_TOKEN, "dents",
  85.    DIFFERENCE_TOKEN, "difference",
  86.    DIFFUSE_TOKEN, "diffuse",
  87.    DIRECTION_TOKEN, "direction",
  88.    DOLLAR_TOKEN, "$",
  89.    DUMP_TOKEN, "dump",
  90.    END_OF_FILE_TOKEN, "End of File",
  91.    EQUALS_TOKEN, "=",
  92.    EXCLAMATION_TOKEN, "!",
  93.    FALLOFF_TOKEN, "falloff",
  94.    FLOAT_TOKEN, "float",
  95.    FOG_TOKEN, "fog",
  96.    FREQUENCY_TOKEN, "frequency",
  97.    GIF_TOKEN, "gif",
  98.    GRANITE_TOKEN, "granite",
  99.    GRADIENT_TOKEN, "gradient",
  100.    GREEN_TOKEN, "green",
  101.    HASH_TOKEN, "#",
  102.    HAT_TOKEN, "^",
  103.    HEIGHT_FIELD_TOKEN, "height_field",
  104.    IDENTIFIER_TOKEN, "identifier",
  105.    IFF_TOKEN, "iff",
  106.    IMAGEMAP_TOKEN, "image_map",
  107.    INCLUDE_TOKEN, "include",
  108.    INTERPOLATE_TOKEN, "interpolate",
  109.    INTERSECTION_TOKEN, "intersection",
  110.    INVERSE_TOKEN, "inverse",
  111.    IOR_TOKEN, "ior",
  112.    LEFT_ANGLE_TOKEN, "<",
  113.    LEFT_CURLY_TOKEN, "{",
  114.    LEFT_PAREN_TOKEN, "(",
  115.    LEFT_SQUARE_TOKEN, "[",
  116.    LEOPARD_TOKEN, "leopard",
  117.    LIGHT_SOURCE_TOKEN, "light_source",
  118.    LOCATION_TOKEN, "location",
  119.    LOOK_AT_TOKEN, "look_at",
  120.    MARBLE_TOKEN, "marble",
  121.    MATERIAL_MAP_TOKEN, "material_map",
  122.    MAPTYPE_TOKEN, "map_type",
  123.    MAX_TRACE_LEVEL_TOKEN, "max_trace_level",
  124.    METALLIC_TOKEN, "metallic",
  125.    MORTAR_TOKEN, "mortar",
  126.    NO_SHADOW_TOKEN, "no_shadow",
  127.    OBJECT_TOKEN, "object",
  128.    OCTAVES_TOKEN, "octaves",
  129.    ONCE_TOKEN, "once",
  130.    ONION_TOKEN, "onion",
  131.    PAINTED1_TOKEN, "painted1",
  132.    PAINTED2_TOKEN, "painted2",
  133.    PAINTED3_TOKEN, "painted3",
  134.    PERCENT_TOKEN, "%",
  135.    PHASE_TOKEN, "phase",
  136.    PHONG_TOKEN, "phong",
  137.    PHONGSIZE_TOKEN, "phong_size",
  138.    PLANE_TOKEN, "plane",
  139.    PLUS_TOKEN, "+",
  140.    POINTS_TOKEN, "points",
  141.    POINT_AT_TOKEN, "point_at",
  142.    POLY_TOKEN, "poly",
  143.    POLYGON_TOKEN, "polygon",
  144.    POT_TOKEN, "pot",
  145.    QUADRIC_TOKEN, "quadric",
  146.    QUARTIC_TOKEN, "quartic",
  147.    QUESTION_TOKEN, "?",
  148.    RADIUS_TOKEN, "radius",
  149.    RAW_TOKEN, "raw",
  150.    RED_TOKEN, "red",
  151.    REFLECTION_TOKEN, "reflection",
  152.    REFRACTION_TOKEN, "refraction",
  153.    REVOLVE_TOKEN, "revolve",
  154.    RIGHT_TOKEN, "right",
  155.    RIGHT_CURLY_TOKEN, "}",
  156.    RIGHT_ANGLE_TOKEN, ">",
  157.    RIGHT_PAREN_TOKEN, ")",
  158.    RIGHT_SQUARE_TOKEN, "]",
  159.    RIPPLES_TOKEN, "ripples",
  160.    ROTATE_TOKEN, "rotate",
  161.    ROUGHNESS_TOKEN, "roughness",
  162.    SCALE_TOKEN, "scale",
  163.    SEMI_COLON_TOKEN, ";",
  164.    SHAPE_TOKEN, "shape",
  165.    SKY_TOKEN, "sky",
  166.    SINGLE_QUOTE_TOKEN, "'",
  167.    SIZE_TOKEN, "size",
  168.    SLASH_TOKEN, "/",
  169.    SMOOTH_TRIANGLE_TOKEN, "smooth_triangle",
  170.    SPECULAR_TOKEN, "specular",
  171.    SPHERE_TOKEN, "sphere",
  172.    SPOTLIGHT_TOKEN, "spotlight",
  173.    SPOTTED_TOKEN, "spotted",
  174.    STAR_TOKEN, "*",
  175.    STRING_TOKEN, "string",
  176.    STURM_TOKEN, "sturm",
  177.    TEXTURE_TOKEN, "texture",
  178.    TGA_TOKEN, "tga",
  179.    TIGHTNESS_TOKEN, "tightness",
  180.    TILDE_TOKEN, "~",
  181.    TILE2_TOKEN, "tile2",
  182.    THRESHOLD_TOKEN, "threshold",
  183.    TRANSLATE_TOKEN, "translate",
  184.    TRANSMIT_TOKEN, "* disabled *", /* Transmit disabled 2/92 */
  185.    TRIANGLE_TOKEN, "triangle",
  186.    TURBULENCE_TOKEN, "turbulence",
  187.    UNION_TOKEN, "union",
  188.    UP_TOKEN, "up",
  189.    USE_COLOUR_TOKEN,"use_color",
  190.    USE_COLOUR_TOKEN,"use_colour",
  191.    USE_INDEX_TOKEN,"use_index",
  192.    VIEW_POINT_TOKEN, "camera",
  193.    WATER_LEVEL_TOKEN, "water_level",
  194.    WAVES_TOKEN, "waves",
  195.    WOOD_TOKEN, "wood",
  196.    WRINKLES_TOKEN, "wrinkles", 
  197.    LAST_TOKEN, "orville" 
  198. };
  199.  
  200. /* Make a table for user-defined symbols.  500 symbols should be more
  201. than enough. */
  202.  
  203. /* Now defined in POVRAY.c */
  204. /* #define MAX_SYMBOLS 500 */
  205. extern int Max_Symbols;
  206.  
  207. int token_count = 0, line_count = 0; /* moved here to allow reinitialization */
  208.  
  209. char **Symbol_Table;
  210. int Number_Of_Symbols;
  211. extern int Case_Sensitive_Flag; /* defined & init in povray.c */
  212.  
  213. #define MAX_INCLUDE_FILES 10
  214.  
  215. DATA_FILE Include_Files[MAX_INCLUDE_FILES];
  216. int Include_File_Index;
  217. DATA_FILE *Data_File;
  218.  
  219. struct Token_Struct Token;
  220.  
  221. #define CALL(x) { if (!(x)) return (FALSE); }
  222.  
  223. void Initialize_Tokenizer(filename)
  224. char *filename;
  225. {
  226.    Symbol_Table = NULL;
  227.    Data_File = NULL;
  228.  
  229.    Include_File_Index = 0;
  230.    Data_File = &Include_Files[0];
  231.  
  232.    Data_File->File = Locate_File (filename, "r");
  233.    if (Data_File->File == NULL) {
  234.       fprintf (stderr, "Cannot open input file\n");
  235.       exit(1);
  236.    }
  237.  
  238.    Data_File->Filename = malloc(strlen(filename) + 1);
  239.    strcpy (Data_File->Filename, filename);
  240.    Data_File->Line_Number = 0;
  241.  
  242.  
  243.    if ((Symbol_Table = (char **) malloc (Max_Symbols * sizeof (char *))) == NULL) {
  244.       fprintf(stderr, "Out of Memory. Cannot allocate space for symbol table\n");
  245.       exit(1);
  246.    }
  247.  
  248.    Token.End_Of_File = FALSE;
  249.    Number_Of_Symbols = 0;
  250. }
  251.  
  252.  
  253. void Terminate_Tokenizer()
  254. {
  255.    int i;
  256.  
  257.    if (Symbol_Table != NULL) {
  258.       for (i = 1 ; i < Number_Of_Symbols ; i++)
  259.          free(Symbol_Table[i]);
  260.  
  261.       free (Symbol_Table);
  262.    }
  263.  
  264.    if (Data_File != NULL) {
  265.       fclose (Data_File->File);
  266.       free (Data_File->Filename);
  267.    }
  268. }
  269.  
  270. /* The main tokenizing routine.  Set up the files and continue parsing
  271. until the end of file */
  272.  
  273. /* This function performs most of the work involved in tokenizing.  It
  274.    reads the first character of the token and decides which function to
  275.    call to tokenize the rest.  For simple tokens, it simply writes them
  276.    out to the token buffer.  */
  277.  
  278. /* Read a token from the input file and store it in the Token variable.
  279. If the token is an INCLUDE token, then set the include file name and
  280. read another token. */
  281.  
  282. void Get_Token ()
  283. {
  284.    register int c,c2;
  285.    COOPERATE
  286.    if(Stop_Flag){
  287.       close_all();
  288.       exit(1);
  289.    }
  290.    if (Token.Unget_Token)
  291.    {
  292.       Token.Unget_Token = FALSE;
  293.       return;
  294.    }
  295.  
  296.    if (Token.End_Of_File)
  297.       return;
  298.  
  299.    Token.Token_Id = END_OF_FILE_TOKEN;
  300.  
  301.    while (Token.Token_Id == END_OF_FILE_TOKEN) {
  302.  
  303.       Skip_Spaces (Data_File);
  304.  
  305.       c = getc(Data_File->File);
  306.       if (c == EOF) {
  307.          if (Include_File_Index == 0) {
  308.             Token.Token_Id = END_OF_FILE_TOKEN;
  309.             Token.End_Of_File = TRUE;
  310.             /*putchar ('\n');*/
  311.             fprintf (stderr,"\n");
  312.             return;
  313.          }
  314.  
  315.          fclose(Data_File->File); /* added to fix open file buildup JLN 12/91 */
  316.  
  317.          Data_File = &Include_Files[--Include_File_Index];
  318.          continue;
  319.       }
  320.  
  321.       String[0] = '\0';
  322.       String_Index  = 0;
  323.  
  324.       switch (c)
  325.       {
  326.       case '\n': Data_File->Line_Number++;
  327.          break;
  328.  
  329.       case '{' : Write_Token (LEFT_CURLY_TOKEN, Data_File);
  330.          /* Parse_Comments(Data_File); */
  331.          break;
  332.  
  333.       case '}' : Write_Token (RIGHT_CURLY_TOKEN, Data_File);
  334.          break;                                    
  335.  
  336.       case '@' : Write_Token (AT_TOKEN, Data_File);
  337.          break;
  338.  
  339.       case '&' : Write_Token (AMPERSAND_TOKEN, Data_File);
  340.          break;
  341.  
  342.       case '`' : Write_Token (BACK_QUOTE_TOKEN, Data_File);
  343.          break;
  344.  
  345.       case '\\': Write_Token (BACK_SLASH_TOKEN, Data_File);
  346.          break;
  347.  
  348.       case '|' : Write_Token (BAR_TOKEN, Data_File);
  349.          break;
  350.  
  351.       case ':' : Write_Token (COLON_TOKEN, Data_File);
  352.          break;
  353.  
  354.       case ',' : Write_Token (COMMA_TOKEN, Data_File);
  355.          break;
  356.  
  357.       case '-' : Write_Token (DASH_TOKEN, Data_File);
  358.          break;
  359.  
  360.       case '$' : Write_Token (DOLLAR_TOKEN, Data_File);
  361.          break;
  362.  
  363.       case '=' : Write_Token (EQUALS_TOKEN, Data_File);
  364.          break;
  365.  
  366.       case '!' : Write_Token (EXCLAMATION_TOKEN, Data_File);
  367.          break;
  368.  
  369.       case '#' : /* Parser doesn't use it, so let's ignore it */
  370.          /* Write_Token (HASH_TOKEN, Data_File); */
  371.          break;
  372.  
  373.       case '^' : Write_Token (HAT_TOKEN, Data_File);
  374.          break;
  375.  
  376.       case '<' : Write_Token (LEFT_ANGLE_TOKEN, Data_File);
  377.          break;
  378.  
  379.       case '(' : Write_Token (LEFT_PAREN_TOKEN, Data_File);
  380.          break;
  381.  
  382.       case '[' : Write_Token (LEFT_SQUARE_TOKEN, Data_File);
  383.          break;
  384.  
  385.       case '%' :  Write_Token (PERCENT_TOKEN, Data_File);
  386.          break;
  387.  
  388.       case '+' : Write_Token (PLUS_TOKEN, Data_File);
  389.          break;
  390.  
  391.       case '?' : Write_Token (QUESTION_TOKEN, Data_File);
  392.          break;
  393.  
  394.       case '>' : Write_Token (RIGHT_ANGLE_TOKEN, Data_File);
  395.          break;
  396.  
  397.       case ')' : Write_Token (RIGHT_PAREN_TOKEN, Data_File);
  398.          break;
  399.  
  400.       case ']' : Write_Token (RIGHT_SQUARE_TOKEN, Data_File);
  401.          break;
  402.  
  403.       case ';' : /* Parser doesn't use it, so let's ignore it */
  404.          /* Write_Token (SEMI_COLON_TOKEN, Data_File); */
  405.          break;
  406.  
  407.       case '\'': Write_Token (SINGLE_QUOTE_TOKEN, Data_File);
  408.          break;
  409.  
  410.          /* enable C++ style commenting */
  411.       case '/' :     c2 = getc(Data_File->File);
  412.          if(c2 != (int) '/' && c2 != (int) '*'){
  413.             ungetc(c2,Data_File->File);
  414.             Write_Token (SLASH_TOKEN, Data_File);
  415.             break;
  416.          }          
  417.          if(c2 == (int)'*'){
  418.             Parse_C_Comments(Data_File);
  419.             break;
  420.          }           
  421.          while(c2 != (int)'\n'){
  422.             c2=getc(Data_File->File);
  423.             if(c2==EOF){
  424.                ungetc(c2,Data_File->File);
  425.                break;
  426.             }
  427.          }
  428.          Data_File->Line_Number++;
  429.          break;
  430.  
  431.       case '*' : Write_Token (STAR_TOKEN, Data_File);
  432.          break;
  433.  
  434.       case '~' : Write_Token (TILDE_TOKEN, Data_File);
  435.          break;
  436.  
  437.       case '"' : Parse_String (Data_File);
  438.          break;
  439.  
  440.       case '0':   case '1':   case '2':   case '3':   case '4':   case '5':
  441.       case '6':   case '7':   case '8':   case '9':   case '.':
  442.          ungetc (c, Data_File->File);
  443.          if (Read_Float (Data_File) != TRUE)
  444.             return;
  445.          break;
  446.  
  447.       case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
  448.       case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
  449.       case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
  450.       case 'v': case 'w': case 'x': case 'y': case 'z':
  451.       case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
  452.       case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
  453.       case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
  454.       case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_':
  455.          ungetc (c, Data_File->File);
  456.          if (Read_Symbol (Data_File) != TRUE)
  457.             return;
  458.          break;
  459.       case '\t':
  460. #ifndef CR_SAME_AS_R
  461.       case '\r':
  462. #endif
  463.       case '\032':   /* Control Z - EOF on many systems */
  464.       case '\0': break;
  465.  
  466.       default:
  467.          fprintf (stderr, "Error in %s line %d\n", Data_File->Filename, Data_File->Line_Number+1);
  468.          fprintf (stderr, "Illegal character in input file, value is %02x\n", c);
  469.          break;
  470.       }
  471.       if (Token.Token_Id == INCLUDE_TOKEN)
  472.       {
  473.          if (Skip_Spaces (Data_File) != TRUE)
  474.             Token_Error (Data_File, "Expecting a string after INCLUDE\n");
  475.  
  476.          if ((c = getc(Data_File->File)) != '"')
  477.             Token_Error (Data_File, "Expecting a string after INCLUDE\n");
  478.  
  479.          Parse_String(Data_File);
  480.          Include_File_Index++;
  481.          if (Include_File_Index > MAX_INCLUDE_FILES)
  482.             Token_Error (Data_File, "Too many nested include files\n");
  483.  
  484.          Data_File = &Include_Files[Include_File_Index];
  485.          Data_File->Line_Number = 0;
  486.  
  487.          Data_File->Filename = malloc(strlen(Token.Token_String) + 1);
  488.          if (Data_File->Filename == NULL) {
  489.             fprintf (stderr, "Out of memory opening include file: %s\n",
  490.                Token.Token_String);
  491.             exit (1);
  492.          }
  493.  
  494.          strcpy (Data_File->Filename, Token.Token_String);
  495.  
  496.          if ((Data_File->File = Locate_File (Token.Token_String, "r")) == NULL) {
  497.             fprintf (stderr, "Cannot open include file: %s\n", Token.Token_String);
  498.             exit(1);
  499.          }
  500.          Token.Token_Id = END_OF_FILE_TOKEN;
  501.       }
  502.  
  503.    }
  504.  
  505.    token_count++;
  506.    if (token_count > 1000) {
  507.       token_count = 0;
  508.       fprintf(stderr,".");
  509.       fflush(stderr);
  510.       line_count++;
  511.       if (line_count > 78) {
  512.          line_count = 0;
  513.          fprintf (stderr,"\n");
  514.       }
  515.    }
  516.    return;
  517. }
  518.  
  519.  
  520. /* Mark that the token has been put back into the input stream.  The next
  521. call to Get_Token will return the last-read token instead of reading a
  522. new one from the file. */
  523.  
  524. void Unget_Token ()
  525. {
  526.    Token.Unget_Token = TRUE;
  527. }
  528.  
  529. /* Skip over spaces in the input file */
  530.  
  531. int Skip_Spaces (Data_File)
  532. DATA_FILE *Data_File;
  533. {
  534.    register int c;
  535.  
  536.    while (TRUE)
  537.    {
  538.       c = getc(Data_File->File);
  539.       if (c == EOF)
  540.          return (FALSE);
  541.  
  542.       if (!(isspace(c) || c == 0x0A))
  543.          break;
  544.  
  545.       if (c == '\n')
  546.          Data_File->Line_Number++;
  547.    }
  548.  
  549.    ungetc (c, Data_File->File);
  550.    return (TRUE);
  551. }
  552. /* The comments on comments are outdated and incorrect */
  553. /* Comments start with an open brace ({) and end with a close brace (}).
  554.    The open brace has been read already.  Continue reading until a close
  555.    brace is encountered. Be sure to count the lines while you're at it.
  556.    Incidently, nested comments are supported (in case you do such esoteric
  557.    things) */
  558.  
  559. int Parse_Comments (Data_File)
  560. DATA_FILE *Data_File;
  561. {
  562.    register int c;
  563.    int End_Of_Comment;
  564.  
  565.    End_Of_Comment = FALSE;
  566.    while (!End_Of_Comment)
  567.    {
  568.       c = getc (Data_File->File);
  569.       if (c == EOF)
  570.       {
  571.          Token_Error (Data_File, "No closing comment found");
  572.          return (FALSE);
  573.       }
  574.  
  575.       if (c == (int) '\n')
  576.          Data_File->Line_Number++;
  577.  
  578.       if (c == (int) '{')
  579.          CALL (Parse_Comments(Data_File))
  580. else
  581.    End_Of_Comment = (c == (int) '}');
  582. }
  583.  
  584. return (TRUE);
  585. }
  586.  
  587. /* C style comments with asterik and slash - CdW 8/91 */
  588.  
  589. int Parse_C_Comments (Data_File)
  590. DATA_FILE *Data_File;
  591. {
  592. register int c,c2;
  593. int End_Of_Comment;
  594.  
  595. End_Of_Comment = FALSE;
  596. while (!End_Of_Comment)
  597. {
  598. c = getc (Data_File->File);
  599. if (c == EOF)
  600. {
  601.    Token_Error (Data_File, "No */ closing comment found");
  602.    return (FALSE);
  603. }
  604.  
  605. if (c == (int) '\n')
  606. Data_File->Line_Number++;
  607.  
  608. if (c == (int) '*'){
  609.    c2= getc(Data_File->File);
  610.    if(c2 != (int) '/')
  611.       ungetc(c2,Data_File->File);
  612.    else
  613.       End_Of_Comment = TRUE;
  614. }
  615. /* Check for and handle nested comments */
  616. if (c == (int) '/'){
  617.    c2= getc(Data_File->File);
  618.    if(c2 != (int) '*')
  619.       ungetc(c2,Data_File->File);
  620.    else 
  621.       Parse_C_Comments(Data_File);
  622. }
  623. }
  624. return (TRUE);
  625. }
  626.  
  627. /* The following routines make it easier to handle strings.  They stuff
  628.    characters into a string buffer one at a time making all the proper
  629.    range checks.  Call Begin_String to start, Stuff_Character to put
  630.    characters in, and End_String to finish.  The String variable contains
  631.    the final string. */
  632.  
  633. void Begin_String()
  634. {
  635. String_Index = 0;
  636. }
  637.  
  638. void Stuff_Character (c, Data_File)
  639. int c;
  640. DATA_FILE *Data_File;
  641. {
  642. if (String_Index < MAX_STRING_INDEX)
  643. {
  644. String [String_Index++] = (char) c;
  645. if (String_Index >= MAX_STRING_INDEX)
  646. {
  647.    Token_Error (Data_File, "String too long");
  648.    String [String_Index-1] = '\0';
  649. }
  650. }
  651. }
  652.  
  653. void End_String (Data_File)
  654. DATA_FILE *Data_File;
  655. {
  656. Stuff_Character ((int) '\0', Data_File);
  657. }
  658.  
  659. /* Read a float from the input file and tokenize it as one token. The phase
  660.    variable is 0 for the first character, 1 for all subsequent characters
  661.    up to the decimal point, 2 for all characters after the decimal
  662.    point, 3 for the E+/- and 4 for the exponent.  This helps to insure
  663.    that the number is formatted properly. E format added 9/91 CEY */
  664.  
  665. int Read_Float(Data_File)
  666. DATA_FILE *Data_File;
  667. {
  668. register int c, Finished, Phase;
  669.  
  670. Finished = FALSE;
  671. Phase = 0;
  672.  
  673. Begin_String();
  674. while (!Finished)
  675. {
  676. c = getc(Data_File->File);
  677. if (c == EOF)
  678. {
  679.    Token_Error (Data_File, "Unexpected end of file");
  680.    return (FALSE);
  681. }
  682.  
  683. switch (Phase)
  684. {
  685. case 0: if (isdigit(c))
  686.       Stuff_Character(c, Data_File);
  687.    else
  688.       if (c == '.') {
  689.          Stuff_Character('0', Data_File);
  690.          ungetc (c, Data_File->File);
  691.       }
  692.       else
  693.          Token_Error (Data_File, "Error in decimal number");
  694.    Phase = 1;
  695.    break;
  696.  
  697. case 1: if (isdigit(c))
  698.       Stuff_Character(c, Data_File);
  699.    else if (c == (int) '.')
  700.    {Stuff_Character(c, Data_File); Phase = 2;
  701.    }
  702.    else
  703.       if ((c == 'e') || (c == 'E'))
  704.       {Stuff_Character(c, Data_File); Phase = 3;
  705.       }
  706.       else Finished = TRUE;
  707.    break;
  708.  
  709.    case 2: if (isdigit(c))
  710.          Stuff_Character(c, Data_File);
  711.       else if ((c == 'e') || (c == 'E'))
  712.       {Stuff_Character(c, Data_File); Phase = 3;
  713.       }
  714.       else Finished = TRUE;
  715.    break;
  716.  
  717.    case 3: if (isdigit(c) || (c == '+') || (c == '-'))
  718.       {Stuff_Character(c, Data_File); Phase = 4;
  719.       }
  720.       else Finished = TRUE;
  721.    break;
  722.  
  723.    case 4: if (isdigit(c))
  724.          Stuff_Character(c, Data_File);
  725.       else Finished = TRUE;
  726.    break;
  727. }
  728. }
  729.  
  730. ungetc (c, Data_File->File);
  731. End_String(Data_File);
  732.  
  733. Write_Token (FLOAT_TOKEN, Data_File);
  734. if (sscanf (String, DBL_FORMAT_STRING, &Token.Token_Float) == 0)
  735. return (FALSE);
  736.  
  737. return (TRUE);
  738. }
  739.  
  740. /* Parse a string from the input file into a token. */
  741. void Parse_String (Data_File)
  742. DATA_FILE *Data_File;
  743. {
  744. register int c;
  745.  
  746. Begin_String();
  747. while (TRUE)
  748. {
  749. c = getc(Data_File->File);
  750. if (c == EOF)
  751. Token_Error (Data_File, "No end quote for string");
  752.  
  753. if (c != (int) '"')
  754. Stuff_Character (c, Data_File);
  755. else
  756.    break;
  757. }
  758. End_String(Data_File);
  759.  
  760. Write_Token (STRING_TOKEN, Data_File);
  761. Token.Token_String = String;
  762. }
  763.  
  764. /* Read in a symbol from the input file.  Check to see if it is a reserved
  765.    word.  If it is, write out the appropriate token.  Otherwise, write the
  766.    symbol out to the Symbol file and write out an IDENTIFIER token. An
  767.    Identifier token is a token whose token number is greater than the
  768.    highest reserved word. */
  769.  
  770. int Read_Symbol (Data_File)
  771. DATA_FILE *Data_File;
  772. {
  773. register int c, Symbol_Id;
  774.  
  775. Begin_String();
  776. while (TRUE)
  777. {
  778. c = getc(Data_File->File);
  779. if (c == EOF)
  780. {
  781.    Token_Error (Data_File, "Unexpected end of file");
  782.    return (FALSE);
  783. }
  784.  
  785. if (isalpha(c) || isdigit(c) || c == (int) '_')
  786. Stuff_Character (c, Data_File);
  787. else
  788. {
  789.    ungetc (c, Data_File->File);
  790.    break;
  791. }
  792. }
  793. End_String(Data_File);
  794.  
  795. /* Ignore the symbol if it was meant for the tokenizer (-2) */  
  796. if ((Symbol_Id = Find_Reserved()) != -1 && Symbol_Id != -2)
  797. Write_Token (Symbol_Id, Data_File);
  798. else
  799. {
  800. /* Ignore the symbol if it was meant for the tokenizer (-2) */  
  801. if (Symbol_Id==-2)
  802. return(TRUE);
  803.  
  804. if ((Symbol_Id = Find_Symbol()) == -1) {
  805.    if (++Number_Of_Symbols < Max_Symbols) {
  806.       if ((Symbol_Table[Number_Of_Symbols] = malloc (strlen(String)+1)) == NULL)
  807.          Token_Error (Data_File, "Out of memory. Cannot allocate space for identifier");
  808.  
  809.       strcpy (Symbol_Table[Number_Of_Symbols], String);
  810.       Symbol_Id = Number_Of_Symbols;
  811.    }
  812.    else {
  813.       fprintf (stderr, "\nToo many symbols. Use +ms### option to raise Max_Symbols.\n");
  814.       exit(1);
  815.    }
  816. }
  817.  
  818.    Write_Token (LAST_TOKEN + Symbol_Id, Data_File);
  819. }
  820.  
  821. return (TRUE);
  822. }
  823.  
  824. /* Return the index the token in the reserved words table or -1 if it
  825.    isn't there. */
  826.  
  827. int Find_Reserved ()
  828. {
  829. register int i;
  830.  
  831. if (pov_stricmp ("case_sensitive_yes", &(String[0])) == 0){
  832. Case_Sensitive_Flag = 0;
  833. return (-2);
  834. }
  835. else if (pov_stricmp ("case_sensitive_no", &(String[0])) == 0){
  836. Case_Sensitive_Flag = 1;
  837. return (-2);
  838. }
  839. /* The optional case sensitive option only checks keywords unsensitive */
  840. /* Symbols can be upper/lower, but not be the same as a keyword */  
  841. else if (pov_stricmp ("case_sensitive_opt", &(String[0])) == 0){
  842. Case_Sensitive_Flag = 2;
  843. return (-2);
  844. }
  845.  
  846. for (i = 0 ; i < LAST_TOKEN ; i++)
  847. if(Case_Sensitive_Flag==0){
  848.    if (strcmp (Reserved_Words[i].Token_Name, &(String[0])) == 0)
  849.       return (Reserved_Words[i].Token_Number);
  850. }
  851. else{ 
  852. if (pov_stricmp (Reserved_Words[i].Token_Name, &(String[0])) == 0)
  853. return (Reserved_Words[i].Token_Number);
  854. } 
  855.  
  856. return (-1);
  857. }
  858.  
  859. /* Check to see if a symbol already exists with this name.  If so, return
  860.     its symbol ID. */
  861.  
  862. int Find_Symbol ()
  863. {
  864. register int i;
  865.  
  866. for (i = 1 ; i <= Number_Of_Symbols ; i++)
  867. if(Case_Sensitive_Flag == 0 || Case_Sensitive_Flag == 2)
  868. if (strcmp (Symbol_Table[i], String) == 0)
  869. return (i);
  870. else if (Case_Sensitive_Flag == 1)
  871. if (pov_stricmp (Symbol_Table[i], String) == 0)
  872. return (i);
  873.  
  874. return (-1);
  875. }
  876.  
  877. /* Write a token out to the token file */
  878. void Write_Token (Token_Id, Data_File)
  879. TOKEN Token_Id;
  880. DATA_FILE *Data_File;
  881. {
  882. Token.Token_Id = Token_Id;
  883. Token.Token_Line_No = Data_File->Line_Number;
  884. Token.Filename = Data_File->Filename;
  885. Token.Token_String = String;
  886.  
  887. if (Token.Token_Id > LAST_TOKEN)
  888. {
  889. Token.Identifier_Number = (int) Token.Token_Id - (int) LAST_TOKEN;
  890. Token.Token_Id = IDENTIFIER_TOKEN;
  891. }
  892. }
  893.  
  894. /* Report an error */
  895. void Token_Error (Data_File, str)
  896. DATA_FILE *Data_File;
  897. char *str;
  898. {
  899. fprintf(stderr, "Error in %s line %d\n", Data_File->Filename, Data_File->Line_Number);
  900. fputs(str, stderr);
  901. fputs("\n\n", stderr);
  902. exit(1);
  903. }
  904. /* Since the stricmp function isn't available on all systems, we've
  905.    provided a simplified version of it here. */
  906.  
  907. static int pov_stricmp (s1, s2)
  908. char *s1, *s2;
  909. {
  910. char c1, c2;
  911.  
  912. while ((*s1 != '\0') && (*s2 != '\0')) {
  913. c1 = *s1++;
  914. c2 = *s2++;
  915. if (islower(c1))
  916. c1 = (char) toupper(c1);
  917. if (islower(c2))
  918. c2 = (char) toupper(c2);
  919. if (c1 < c2)
  920. return (-1);
  921. if (c1 > c2)
  922. return (1);
  923. }
  924.  
  925. if (*s1 == '\0')
  926. if (*s2 == '\0')
  927. return (0);
  928. else
  929. return (-1);
  930. else
  931. return (1);
  932. }
  933.