readworld.l

Go to the documentation of this file.

%{
/*
* Lexical analizer for the function that initilizes a set of multilineal equations from a file
*/

#include <stdlib.h> 
#include <string.h>
#include "defines.h"
#include "error_world.h"
#include "readworld.tab.h"

int ReadWorldlex(void);

extern unsigned int RWline; /*current line number (declared in the YACC module and updated here)*/

%} 
%s IN_COMMENT

EMPTY                           [ \t]+ 
RETURN                          \n
DIGIT                           [0-9] 
LETTER                          [a-zA-Z]
R_NUMBER                        (({DIGIT}+(\.{DIGIT}+)?)|(\.{DIGIT}+))((E|e)[+-]?{DIGIT}+)? 
I_NUMBER                        {DIGIT}+ 
STRING                          \"[^\"]+\"
IDENTIFIER                      {LETTER}({DIGIT}|{LETTER}|"_")* 
COMMENT                         \%[^\n]*
COMMENT2                        \#[^\n]*
COMMENT3                        \/\/[^\n]*

%%
{COMMENT}                       { }  
{COMMENT2}                      { }   
{COMMENT3}                      { } 

<INITIAL>{
  "/*"              BEGIN(IN_COMMENT);
}
<IN_COMMENT>{
  "*/"      BEGIN(INITIAL);
  [^*\n]+   // eat comment in chunks
  "*"       // eat the lone star
  \n        RWline++;
}

{EMPTY}                         { } 

{RETURN}                        { RWline++; } 

"[CONSTANTS]"                   {
                                  return(_CONSTANTS);
                                }

":="                            {
                                  return(_ASSIGN); 
                                }

PI                              {
                                  return(_PI);
                                }

SIN                             {
                                  return(_SIN);
                                }

COS                             {
                                  return(_COS);
                                }

SQRT                            {
                                  return(_SQRT);
                                }

"[LINKS]"                       {
                                  return(_LINKS);
                                }

"BODY"                          {
                                  return(_BODY);
                                }

"GRANULARITY"                   {
                                  return(_GRANULARITY);
                                }

"[JOINTS]"                      {
                                  return(_JOINTS);
                                }

"FIX"                           {
                                  return(_FIX);
                                }

"ID"                            {
                                  return(_ID);
                                }

"TX"                            {
                                  return(_TX);
                                }

"TY"                            {
                                  return(_TY);
                                }

"TZ"                            {
                                  return(_TZ);
                                }

"TXYZ"                          {
                                  return(_TXYZ);
                                }

"RX"                            {
                                  return(_RX);
                                }

"RY"                            {
                                  return(_RY);
                                }

"RZ"                            {
                                  return(_RZ);
                                }

"PRISMATIC"                     {
                                  return(_PRISMATIC);
                                }

"REVOLUTE"                      {
                                  return(_REVOLUTE);
                                }

"SPHERICAL"                     {
                                  return(_SPHERICAL);
                                }

"UNIVERSAL"                     {
                                  return(_UNIVERSAL);
                                }

"SPH_SPH"                       {
                                  return(_SPH_SPH);
                                }

"IN_PATCH"                      {
                                  return(_IN_PATCH);
                                }

"LENGTH"                        {
                                  return(_LENGTH);
                                }

"RADIUS"                        {
                                  return(_RADIUS);
                                }

"SPHERE"                        {
                                  return(_SPHERE);
                                }

"CYLINDER"                      {
                                  return(_CYLINDER);
                                }

"COLOR"                         {
                                  return(_COLOR);
                                }

"RED"                           {
                                  return(_RED);
                                }

"GREEN"                         {
                                  return(_GREEN);
                                }

"BLUE"                          {
                                  return(_BLUE);
                                }

"WHITE"                         {
                                  return(_WHITE);
                                }

"BLACK"                         {
                                  return(_BLACK);
                                }

"YELLOW"                        {
                                  return(_YELLOW);
                                }

"CYAN"                          {
                                  return(_CYAN);
                                }

"PURPLE"                        {
                                  return(_PURPLE);
                                }

"RANGE"                         {
                                  return(_RANGE);
                                }

"AVOID"                         {
                                  return(_AVOID);
                                }

"LIMITS"                        {
                                  return(_LIMITS);
                                }

{I_NUMBER}                      { 
                                  char string_tmp[100];
                                  
                                  memcpy(string_tmp,ReadWorldtext,(unsigned int)ReadWorldleng);
                                  string_tmp[ReadWorldleng]=0;
                                  ReadWorldlval.int_number=atoi(string_tmp);
                                  return(_INTEGER); 
                                } 
 
{R_NUMBER}                      { 
                                  char string_tmp[100];
                                  
                                  memcpy(string_tmp,ReadWorldtext,(unsigned int)ReadWorldleng);
                                  string_tmp[ReadWorldleng]=0;
                                  ReadWorldlval.real_number=atof(string_tmp);
                                  
                                  return(_REAL);
                                } 

{STRING}                        { 
                                  NEW(ReadWorldlval.string,ReadWorldleng,char);
                                  
                                  memcpy(ReadWorldlval.string,&(ReadWorldtext[1]),(unsigned int)ReadWorldleng-2);
                                  ReadWorldlval.string[ReadWorldleng-2]=0;
                                  
                                  return(_STRING);
                                } 
  
{IDENTIFIER}                    { 
                                  NEW(ReadWorldlval.id,ReadWorldleng+1,char);
                                  memcpy(ReadWorldlval.id,ReadWorldtext,(unsigned int)ReadWorldleng);
  
                                  ReadWorldlval.id[ReadWorldleng]=0;

                                  return(_IDENTIFIER);  
                                }

.                               { return(ReadWorldtext[0]); }
 
%%


/*
 * This function is automatically called by the parser at the end of a file.
 * If 1 is returned the lexical analysis is stopped.
 */
int ReadWorldwrap()
{
  return(1);
}