distrib/sources/api/api/gen_tree_lexer.l

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   Alliance                     */
   4 /*                                                                          */
   5 /*    Produit : GENIUS   v1.00                                              */
   6 /*    Fichier : gen_tree_lexer.lex                                          */
   7 /*                                                                          */
   8 /*    (c) copyright 1999 Laboratoire MASI equipe CAO & VLSI                 */
   9 /*    Tous droits reserves                                                  */
  10 /*    Support : e-mail alliance-support@asim.lip6.fr                        */
  11 /*                                                                          */
  12 /*    Auteur(s) : Francois DONNET                        le : 04/05/1999    */
  13 /*                                                                          */
  14 /*    Modifie par :                                     le : ../../....     */
  15 /*    Modifie par :                                     le : ../../....     */
  16 /*    Modifie par :                                     le : ../../....     */
  17 /*                                                                          */
  18 /****************************************************************************/
  19
  20
  21 %{
  22 #include <math.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include MUT_H
  26 #include "gen_tree_utils.h"
  27 //#include "gen_model_utils.h"
  28 #include "gen_tree_parser.h"
  29
  30 #define yylval gen_tree_parserlval
  31
  32 int lineno=1;                       /* to count the number of lines parsed */
  33 char *genius_yyin=NULL;
  34 static int start_C=0, count=0, start_VHDL=0, in_compon=0;                 /*to lock start condition */
  35
  36 extern char *model_corresp(char *name);
  37
  38 chain_list *PRAGMA_SPLIT(char *line);
  39 int countret(char *str);
  40 static char *known_pragmas[]={"symmetric","coupled","exclude","without","unused","exclude_at_end","stop_at_power_supplies","forcematch"};
  41
  42 #define YY_NO_UNPUT
  43 /*
  44 #define YY_INPUT(buf,res,taille_max) \
  45 { \
  46 if (yyin!=NULL) { int c = fgetc(yyin); res = (c == EOF) ? YY_NULL : (buf[0] = c, 1);  } \
  47 else { if (*genius_yyin=='\0') res=YY_NULL; else {buf[0] = *genius_yyin; genius_yyin++; res=1; } } \
  48 }
  49 */
  50 %}
  51 num ([0-9]+)
  52 hexa (0[xX](([1-9a-fA-F][0-9a-fA-F]*)|0))
  53 letter ('.')
  54 word_vhdl ([a-zA-Z](_?[a-zA-Z0-9])*)
  55 word_c ([a-zA-Z_][a-zA-Z0-9_]*)
  56
  57 %x C
  58 %x VHDL
  59 %x COMMENT_C
  60 %x STRING
  61
  62 %%
  63 <INITIAL,VHDL,C>[ \t]                                                   {}
  64 <INITIAL,VHDL,C,COMMENT_C>\n                       {lineno++;}
  65 <VHDL>\"                                                                        {BEGIN STRING; start_C=0;}
  66 <C,STRING>\"\"                                                          {yylval.string=(char*)mbkalloc(1);
  67                                      yylval.string[0]='\0';
  68                                      return GEN_TOKEN_STRING;}
  69 <C>\"                                   {BEGIN STRING; start_C=1;}
  70 <STRING>\"                          {if (start_C) BEGIN C;
  71                                      else BEGIN INITIAL;}
  72 <STRING>\\\"                        {yylval.string=(char*)mbkalloc(2);
  73                                      yylval.string[0]='"';
  74                                      yylval.string[1]='\0';
  75                                      return GEN_TOKEN_STRING;}
  76 <STRING>\\n                         {yylval.string=(char*)mbkalloc(2);
  77                                      yylval.string[0]='\n';
  78                                      yylval.string[1]='\0';
  79                                      return GEN_TOKEN_STRING;}
  80 <STRING>\\r                         {yylval.string=(char*)mbkalloc(2);
  81                                      yylval.string[0]='\r';
  82                                      yylval.string[1]='\0';
  83                                      return GEN_TOKEN_STRING;}
  84 <STRING>\\b                         {yylval.string=(char*)mbkalloc(2);
  85                                      yylval.string[0]='\b';
  86                                      yylval.string[1]='\0';
  87                                      return GEN_TOKEN_STRING;}
  88 <STRING>\\\\                        {yylval.string=(char*)mbkalloc(2);
  89                                      yylval.string[0]='\\';
  90                                      yylval.string[1]='\0';
  91                                      return GEN_TOKEN_STRING;}
  92 <STRING>\\t                         {yylval.string=(char*)mbkalloc(2);
  93                                      yylval.string[0]='\t';
  94                                      yylval.string[1]='\0';
  95                                      return GEN_TOKEN_STRING;}
  96 <STRING>\\.                         {yylval.string=(char*)mbkalloc(3);
  97                                      strcpy(yylval.string,yytext);
  98                                      return GEN_TOKEN_STRING;}
  99 <STRING>[^\\\"]*                    {int i,taille=strlen(yytext);
 100                                      yylval.string=(char*) mbkalloc(taille+1);
 101                                      strcpy(yylval.string,yytext);
 102                                      for (i=0;i<taille;i++)
 103                                        if (yytext[i]=='\n') lineno++;
 104                                      return GEN_TOKEN_STRING;}
 105 <VHDL,C,INITIAL>\/\*                                               {BEGIN COMMENT_C;}
 106 <COMMENT_C>\*\/                                 {if (start_C) BEGIN C; else if (start_VHDL) BEGIN VHDL; else BEGIN INITIAL;}
 107 <COMMENT_C>.                                       {}
 108 <VHDL,C,INITIAL>\/\/[^\n]*                                {}
 109 <VHDL,INITIAL>\-\-.*                                    { chain_list *cl;
 110   cl=PRAGMA_SPLIT(&yytext[2]);
 111   if (cl!=NULL) { unsigned int i; for (i=0;i<sizeof(known_pragmas)/sizeof(*known_pragmas);i++) if (strcmp(known_pragmas[i],(char *)cl->DATA)==0) { yylval.chain=cl; return GEN_TOKEN_PRAGMA_SYM; } }
 112   freechain(cl);
 113  }
 114 <VHDL>[bB][eE][gG][iI][nN]           { return GEN_TOKEN_BEGIN; }
 115 <VHDL>[eE][nN][dD]                   { count--; if (in_compon==1) in_compon=2; return GEN_TOKEN_END;}
 116 <INITIAL>void                        { start_C=2; BEGIN C; return GEN_TOKEN_VOIDTOKEN; }
 117 <C>void                              { return GEN_TOKEN_VOIDTOKEN; }
 118 <INITIAL>[eE][nN][tT][iI][tT][yY]       { count++; start_VHDL=1; BEGIN VHDL; return GEN_TOKEN_ENTITY;}
 119 <INITIAL>[aA][rR][cC][hH][iI][tT][eE][cC][tT][uU][rR][eE]       { count++; start_VHDL=1; BEGIN VHDL; return GEN_TOKEN_ARCHITECTURE;}
 120 <VHDL>[oO][fF]                                     {return GEN_TOKEN_OF;}
 121 <VHDL>[iI][sS]                                                {return GEN_TOKEN_IS;}
 122 <VHDL>[cC][oO][mM][pP][oO][nN][eE][nN][tT]      { if (in_compon==0) { count++; in_compon=1; } return GEN_TOKEN_COMPONENT;}
 123 <VHDL>[sS][iI][gG][nN][aA][lL]                     {return GEN_TOKEN_SIGNAL;}
 124 <VHDL>[vV][aA][rR][iI][aA][bB][lL][eE]  {return GEN_TOKEN_VARIABLE;}
 125 <VHDL>[iI][nN][tT][eE][gG][eE][rR]                      {return GEN_TOKEN_INTEGER;}
 126 <VHDL>[oO][uU][tT]                                              {return GEN_TOKEN_OUT;}
 127 <VHDL>[iI][nN][oO][uU][tT]                         {return GEN_TOKEN_INOUT;}
 128 <VHDL>[dD][oO][wW][nN][tT][oO]                          {return GEN_TOKEN_DOWNTO;}
 129 <VHDL>[tT][oO]                                          {return GEN_TOKEN_TO;}
 130 <VHDL>[bB][iI][tT]                                         {return GEN_TOKEN_BIT;}
 131 <VHDL>[bB][iI][tT]_[vV][eE][cC][tT][oO][rR]   {return GEN_TOKEN_BIT_VECTOR;}
 132 <VHDL>[wW][oO][rR]_[bB][iI][tT]                 {return GEN_TOKEN_WOR_BIT;}
 133 <VHDL>[bB][uU][sS]                                      {return GEN_TOKEN_BUS;}
 134 <VHDL>[mM][uU][xX]_[bB][iI][tT]                 {return GEN_TOKEN_MUX_BIT;}
 135 <VHDL>[wW][oO][rR]_[vV][eE][cC][tT][oO][rR]     {return GEN_TOKEN_WOR_VECTOR;}
 136 <VHDL>[mM][uU][xX]_[vV][eE][cC][tT][oO][rR]     {return GEN_TOKEN_MUX_VECTOR;}
 137 <VHDL>[pP][oO][rR][tT]                          {return GEN_TOKEN_PORT;}
 138 <VHDL>[mM][aA][pP]                                      {return GEN_TOKEN_MAP;}
 139 <VHDL>[fF][oO][rR]                                      { count++; return GEN_TOKEN_FOR;}
 140 <VHDL>[gG][eE][nN][eE][rR][aA][tT][eE]          {return GEN_TOKEN_GENERATE;}
 141 <VHDL>[gG][eE][nN][eE][rR][iI][cC]                      {return GEN_TOKEN_GENERIC;}
 142 <VHDL>[iI][nN]                                          {return GEN_TOKEN_IN;}
 143 <VHDL>[aA][nN][dD]                                      {return GNS_TOKEN_AND;}
 144 <VHDL>[nN][aA][nN][dD]                                  {return GEN_TOKEN_NAND;}
 145 <VHDL>[oO][rR]                                          {return GEN_TOKEN_OR;}
 146 <VHDL>[nN][oO][rR]                                      {return GEN_TOKEN_NOR;}
 147 <VHDL>[xX][oO][rR]                                      {return GEN_TOKEN_XOR;}
 148 <VHDL>[nN][oO][tT]                                      {return GEN_TOKEN_NOT;}
 149 <VHDL>[mM][oO][dD]                                      {return GEN_TOKEN_MOD;}
 150 <VHDL>[rR][eE][mM]                                      {return GEN_TOKEN_REM;}
 151 <VHDL>[aA][bB][sS]                                      {return GEN_TOKEN_ABSOL;}
 152 <INITIAL>{word_c}[ \n\t]*[\*]*[ \n\t]*{word_c}[ \n\t]*\( {
 153                          yylval.string=sensitive_namealloc(yytext);
 154                          start_C=1; BEGIN C;
 155                          lineno+=countret(yylval.string);
 156                          return GEN_TOKEN_FONCTION_HEADER;
 157                          }
 158 <C>exclude                                      {return GEN_TOKEN_EXCLUDE;}
 159 <C>printf                                                       {return GEN_TOKEN_PRINTF;}
 160 <C>fprintf                                              {return GEN_TOKEN_FPRINTF;}
 161 <C>sprintf                                              {return GEN_TOKEN_SPRINTF;}
 162 <C>exit                                                    {return GEN_TOKEN_EXIT;}
 163 <C>return                                               {return GEN_TOKEN_RETURN;}
 164 <C>break                                                {return GEN_TOKEN_BREAK;}
 165 <C>NULL                                                 {return GEN_TOKEN_NULL;}
 166 <C>for                                          {return GEN_TOKEN_FOR;}
 167 <C>do                                              {return GEN_TOKEN_DO;}
 168 <C>while                                                {return GEN_TOKEN_WHILE;}
 169 <C>if                                                           {return GEN_TOKEN_IF;}
 170 <C>else                                                                 {return GEN_TOKEN_ELSE;}
 171
 172 <INITIAL>int               { start_C=2; BEGIN C; return GEN_TOKEN_INTEGER;}
 173 <INITIAL>long              { start_C=2; BEGIN C; return GEN_TOKEN_LONG;}
 174 <INITIAL>double            { start_C=2; BEGIN C; return GEN_TOKEN_DOUBLE; }
 175 <INITIAL>FILE              { start_C=2; BEGIN C; return GEN_TOKEN_FILE;}
 176 <INITIAL>char              { start_C=2; BEGIN C; return GEN_TOKEN_CHAR;}
 177 <INITIAL>{word_c}          {
 178                              yylval.string=sensitive_namealloc(yytext);
 179
 180                              start_C=2; BEGIN C;
 181                              return GEN_TOKEN_IDENT;
 182                            }
 183 <C>int                                          {/*only lowcase in C */return GEN_TOKEN_INTEGER;}
 184 <C>long                                         { return GEN_TOKEN_LONG; }
 185 <C>double                                       { return GEN_TOKEN_DOUBLE; }
 186 <C>FILE                                         {return GEN_TOKEN_FILE;}
 187 <C>char                                         {return GEN_TOKEN_CHAR;}
 188 <C>static                                       {return GEN_TOKEN_STATIC;}
 189 <C>READ_TEXT                                    {yylval.string=
 190                                        (char*) mbkalloc(strlen(READ_TEXT)+1);
 191                                      strcpy(yylval.string,READ_TEXT);
 192                                      return GEN_TOKEN_STRING;}
 193 <C>WRITE_TEXT                                   {yylval.string=
 194                                        (char*) mbkalloc(strlen(WRITE_TEXT)+1);
 195                                      strcpy(yylval.string,WRITE_TEXT);
 196                                      return GEN_TOKEN_STRING;}
 197 \*\*                                    {return GEN_TOKEN_POW;}
 198 <VHDL,C>[,]             { return ','; }
 199 <VHDL,C>[;]             { if (start_VHDL && count==0) { start_VHDL=0; BEGIN INITIAL; }
 200                           if (start_C==2) {start_C=0; BEGIN INITIAL; }
 201                           if (in_compon==2) in_compon=0;
 202                           return ';';
 203                         }
 204 <VHDL,C>\(                                                              {return '(';}
 205 <VHDL,C>\)                                                              {return ')';}
 206 <C>\=                                                                                   {return '=';}
 207 <VHDL>\=                                                                {return GEN_TOKEN_EG;}
 208 <C>\+\+                                                                                 {return GEN_TOKEN_INC;}
 209 <C>\+\=                                                                         {return GEN_TOKEN_EG_ADD;}
 210 <VHDL,C>\+                                                              {return '+';}
 211 <C>--                                                                                   {return GEN_TOKEN_DEC;}
 212 <C>-\=                                                                          {return GEN_TOKEN_EG_SUB;}
 213 <VHDL,C>-                                                               {return '-';}
 214 <C>\*\=                                                                         {return GEN_TOKEN_EG_MUL;}
 215 <VHDL,C>\*                                                              {return '*';}
 216 <C>\/\=                                                                         {return GEN_TOKEN_EG_DIV;}
 217 <VHDL,C>\/                                                              {return '/';}
 218 <C>%\=                                                                          {return GEN_TOKEN_EG_MOD;}
 219 <C>%                                                                                    {return '%';}
 220 <C>\^\=                                                                         {return GEN_TOKEN_EG_XOR;}
 221 <C>\^                                                                                   {return '^';}
 222 <C>!                                                                                    {return '!';}
 223 <C>&&                                                                                   {return GNS_TOKEN_AND;}
 224 <C>\&\=                                                                         {return GEN_TOKEN_EG_AND;}
 225 <VHDL,C>&                                                               {return '&';}
 226 <C>\|\|                                                                         {return GEN_TOKEN_OR;}
 227 <C>\|\=                                                                         {return GEN_TOKEN_EG_OR;}
 228 <C>\|                                                                                   {return '|';}
 229 <C>~                                                                                    {return '~';}
 230 <C>\<\<                                                                         {return GEN_TOKEN_SHL;}
 231 <VHDL,C>\<                                                              {return '<';}
 232 <C>\>\>                                                                         {return GEN_TOKEN_SHR;}
 233 <VHDL,C>\>                                                              {return '>';}
 234 <C>\=\=                                                                         {return GEN_TOKEN_EG;}
 235 <C>\<\=                                                                         {return GEN_TOKEN_INFEG;}
 236 <C>\>\=                                                                         {return GEN_TOKEN_SUPEG;}
 237 <C>!\=                                                                          {return GEN_TOKEN_NOTEG;}
 238 <VHDL>\/\=                                                                                      {return GEN_TOKEN_NOTEG;}
 239 <C>\?                                                                                   {return '?';}
 240 <VHDL,C>\:                                                              {return ':';}
 241 <C>\[                                                                                   {return '[';}
 242 <C>\]                                                                                   {return ']';}
 243 <VHDL>\=\>                                                                                      {return GEN_TOKEN_EQUI;}
 244 <VHDL,C>{letter}                                {yylval.integer=yytext[1]; return GEN_TOKEN_DIGIT_CHAR;}
 245 <VHDL,C>{num}(\.{num})?[eE][+-]?{num}   {yylval.real=(double *)mbkalloc(sizeof(double)); *yylval.real=strtod(yytext,NULL); return GEN_TOKEN_DIGIT_DOUBLE;}
 246 <VHDL,C>{num}\.{num}    {yylval.real=(double *)mbkalloc(sizeof(double)); *yylval.real=strtod(yytext,NULL); return GEN_TOKEN_DIGIT_DOUBLE;}
 247 <VHDL,C>{num}                                   {yylval.integer=atoi(yytext);
 248                                                          return GEN_TOKEN_DIGIT;}
 249 <C>{hexa}                               {int i,val,taille=strlen(yytext)-1;
 250                                      yylval.integer=0;
 251                                      for (i=taille;i>=2/*0x*/;i--) {
 252                                       if (yytext[i]>='a')
 253                                           val=yytext[i]-'a'+10;
 254                                       else if (yytext[i]>='A')
 255                                           val=yytext[i]-'A'+10;
 256                                       else val=yytext[i]-'0';
 257                                       yylval.integer+=val*pow(16,taille-i);
 258                                      }
 259                                      return GEN_TOKEN_DIGIT;}
 260 <VHDL>{word_vhdl}                       {yylval.string=namealloc(yytext); return GEN_TOKEN_IDENT;}
 261 <C>{word_c}                     { yylval.string=sensitive_namealloc(yytext); return GEN_TOKEN_IDENT;}
 262 <C>\{                                {count++;return '{';}
 263 <C>\}                                {count--;if (count==0) {BEGIN INITIAL;start_C=0;} return '}';}
 264 <INITIAL,VHDL,C,COMMENT_C,STRING><<EOF>>        {return GEN_TOKEN_STOP;}
 265 <INITIAL,VHDL,C,COMMENT_C,STRING>.                      {return *yytext;}
 266 %%
 267
 268 /*****************************************************************************/
 269 /*                stop searching other files to parse ?                      */
 270 /*****************************************************************************/
 271 extern int yywrap() {
 272        return 1;
 273 }
 274
 275 void init_lexer()
 276 {
 277   start_C=0, count=0, start_VHDL=0, in_compon=0;
 278 BEGIN INITIAL;
 279 }
 280
 281
 282 char *mysep(char **next, char sep)
 283 {
 284   char *first=*next;
 285   while (**next==sep && **next!='\0') (*next)++;
 286   if (**next=='\0') { first=*next; *next=NULL; return first; }
 287   first=*next;
 288   while (**next!=sep && **next!='\0') (*next)++;
 289   if (**next=='\0') *next=NULL;
 290   else
 291     {
 292       **next='\0';
 293       (*next)++;
 294     }
 295   return first;
 296 }
 297
 298
 299 chain_list *PRAGMA_SPLIT(char *line)
 300 {
 301   chain_list *cl=NULL;
 302   char *token, *next;
 303   next=line;
 304 //  printf(" '%s'\n",line);
 305   token=mysep(&next, ' ');
 306  // printf(" %s\n",token);
 307   if (next==NULL || strcmp(token, "pragma")!=0) return NULL;
 308   do
 309     {
 310       token=mysep(&next, ' ');
 311       if (token[0]!='\0')
 312         {
 313         //  printf("  %s\n",token);
 314           cl=addchain(cl, model_corresp(token));
 315         }
 316     } while (next!=NULL);
 317   cl=reverse(cl);
 318   return cl;
 319 }
 320
 321 int countret(char *str)
 322 {
 323   int i, c=0;
 324   for (i=0; str[i]!='\0'; i++) if (str[i]=='\n') c++;
 325   return c;
 326 }