src/lexer.l

   1 /* GOB C Preprocessor
   2  * Copyright (C) 1999 the Free Software Foundation.
   3  *
   4  * Author: George Lebl
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the  Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19  * USA.
  20  */
  21 %{
  22
  23 #include "config.h"
  24 #include <glib.h>
  25 #include <string.h>
  26
  27 #include "parse.h"
  28 #include "main.h"
  29
  30 extern gboolean for_cpp;
  31
  32 static int parenth_depth = 0;
  33 static int before_comment = INITIAL;
  34 static int class_after_c = FALSE;
  35 static int header_c = FALSE;
  36
  37 static GString *cbuf = NULL;
  38 int ccode_line = 1;
  39
  40 GList *include_files = NULL;
  41 /* 0 no, 1 means yes, 2+ means don't even start looking anymore */
  42 static int look_for_includes = 0;
  43
  44 int line_no = 1;
  45
  46 static void
  47 clear_cbuf(void)
  48 {
  49         if(!cbuf) {
  50                 cbuf = g_string_new("");
  51         } else {
  52                 cbuf = g_string_assign(cbuf,"");
  53         }
  54 }
  55
  56 static void
  57 add_to_cbuf(char *s)
  58 {
  59         if(!cbuf) {
  60                 cbuf = g_string_new(s);
  61         } else {
  62                 cbuf = g_string_append(cbuf,s);
  63         }
  64 }
  65
  66 %}
  67
  68 %x COMMENT
  69 %x C_CODE
  70 %x C_CODE_STRING
  71 %x CLASS_CODE
  72 %x CLASS_CODE_I
  73
  74 %%
  75
  76 <*>\n                   { line_no++; REJECT; }
  77
  78 <*>MOTHERFUCKER         { fprintf(stderr,"You are a bad bad person!\n"); REJECT; }
  79
  80 \/\/.*$                 { ; /*comment, ignore*/ }
  81 <C_CODE>^#[ \t]*include[ \t][<"][^\n">]*[>"] {
  82         if(look_for_includes==1) {
  83                 char *p;
  84                 char *file;
  85                 char *str = g_strdup(yytext);
  86                 file = strchr(str,'"');
  87                 if(!file) file = strchr(str,'<');
  88                 file++;
  89                 p = strchr(file,'"');
  90                 if(!p) p = strchr(file,'>');
  91                 *p = '\0';
  92                 include_files = g_list_prepend(include_files,g_strdup(file));
  93                 g_free(str);
  94         }
  95         REJECT;
  96 }
  97
  98 <C_CODE>\/\/.*$         { add_to_cbuf(yytext); /*comment, ignore*/ }
  99 <CLASS_CODE>\/\/.*$     { ; /*comment, ignore*/ }
 100 <CLASS_CODE_I>\/\/.*$   { ; /*comment, ignore*/ }
 101 \/\*            {BEGIN(COMMENT); before_comment = INITIAL; }
 102 <C_CODE>\/\*    {
 103         add_to_cbuf(yytext);
 104         BEGIN(COMMENT);
 105         before_comment = C_CODE;
 106 }
 107 <CLASS_CODE>\/\*        {BEGIN(COMMENT); before_comment = CLASS_CODE; }
 108 <CLASS_CODE_I>\/\*      {BEGIN(COMMENT); before_comment = CLASS_CODE_I; }
 109 <COMMENT>\*\/   {
 110         if(before_comment == C_CODE) add_to_cbuf(yytext);
 111         BEGIN(before_comment);
 112                 }
 113 <COMMENT>.      {
 114         /* comment, ignore */
 115         if(before_comment == C_CODE) add_to_cbuf(yytext);
 116                 }
 117 <COMMENT>\n     {
 118         /* comment, ignore */
 119         if(before_comment == C_CODE) add_to_cbuf(yytext);
 120                 }
 121
 122 ^\%h\{          {
 123                         BEGIN(C_CODE);
 124                         parenth_depth = 1;
 125                         class_after_c = FALSE;
 126                         header_c = TRUE;
 127                         clear_cbuf();
 128                         ccode_line = line_no;
 129                 }
 130 ^\%\{           {
 131                         BEGIN(C_CODE);
 132                         parenth_depth = 1;
 133                         class_after_c = FALSE;
 134                         header_c = FALSE;
 135                         clear_cbuf();
 136                         ccode_line = line_no;
 137                         if(look_for_includes==0)
 138                                 look_for_includes=1;
 139                 }
 140 <C_CODE>^\%\}   {
 141                         BEGIN(INITIAL);
 142                         yylval.cbuf = cbuf;
 143                         cbuf = NULL;
 144                         if(look_for_includes==1)
 145                                 look_for_includes=0;
 146                         if(header_c)
 147                                 return HCODE;
 148                         else
 149                                 return CCODE;
 150                 }
 151
 152 <C_CODE>\'\{\'          { add_to_cbuf(yytext); }
 153 <C_CODE>\'\\\{\'        { add_to_cbuf(yytext); }
 154 <C_CODE>\'\}\'          { add_to_cbuf(yytext); }
 155 <C_CODE>\'\\\}\'        { add_to_cbuf(yytext); }
 156 <C_CODE>\'\"\'          { add_to_cbuf(yytext); }
 157 <C_CODE>\'\\\"\'        { add_to_cbuf(yytext); }
 158
 159 <C_CODE>\\.     { add_to_cbuf(yytext); }
 160 <C_CODE>\"      {
 161                         BEGIN(C_CODE_STRING);
 162                         add_to_cbuf(yytext);
 163                 }
 164 <C_CODE_STRING>\\.      { add_to_cbuf(yytext); }
 165 <C_CODE_STRING>\"       {
 166                                 BEGIN(C_CODE);
 167                                 add_to_cbuf(yytext);
 168                         }
 169 <C_CODE_STRING>.        { add_to_cbuf(yytext); }
 170 <C_CODE_STRING>\n       { add_to_cbuf(yytext); }
 171
 172 <C_CODE>\{      {
 173                         parenth_depth++;
 174                         add_to_cbuf(yytext);
 175                 }
 176 <C_CODE>\}      {
 177                         parenth_depth--;
 178                         if(parenth_depth<0) {
 179                                 REJECT;
 180                         } else if(parenth_depth==0 && class_after_c) {
 181                                 BEGIN(CLASS_CODE_I);
 182                                 yylval.cbuf = cbuf;
 183                                 cbuf = NULL;
 184                                 return CCODE;
 185                         }
 186                         add_to_cbuf(yytext);
 187                 }
 188
 189 <C_CODE>.       { add_to_cbuf(yytext); }
 190 <C_CODE>\n      { add_to_cbuf(yytext); }
 191
 192 class           {
 193                         look_for_includes = 2;
 194                         BEGIN(CLASS_CODE);
 195                         return CLASS;
 196                 }
 197
 198 <CLASS_CODE,CLASS_CODE_I>class|this     {
 199                         if(for_cpp) {
 200                                 char *s;
 201                                 s = g_strdup_printf("'%s' keyword should not "
 202                                                     "be used when generating "
 203                                                     "C++ code",yytext);
 204                                 print_error(TRUE,s, line_no);
 205                                 g_free(s);
 206                         }
 207                         REJECT;
 208                 }
 209
 210 <CLASS_CODE>from        {return FROM;}
 211
 212 <CLASS_CODE_I>void      {return VOID;}
 213 <CLASS_CODE_I>struct    {return STRUCT;}
 214 <CLASS_CODE_I>union     {return UNION;}
 215 <CLASS_CODE_I>enum      {return ENUM;}
 216 <CLASS_CODE_I>signed    {return SIGNED;}
 217 <CLASS_CODE_I>unsigned  {return UNSIGNED;}
 218 <CLASS_CODE_I>long      {return LONG;}
 219 <CLASS_CODE_I>short     {return SHORT;}
 220 <CLASS_CODE_I>int       {return INT;}
 221 <CLASS_CODE_I>float     {return FLOAT;}
 222 <CLASS_CODE_I>double    {return DOUBLE;}
 223 <CLASS_CODE_I>char      {return CHAR;}
 224 <CLASS_CODE_I>const     {return CONST;}
 225
 226 <CLASS_CODE_I>\.\.\.    {return THREEDOTS;}
 227
 228 <CLASS_CODE_I>public    {yylval.line = line_no; return PUBLIC;}
 229 <CLASS_CODE_I>private   {yylval.line = line_no; return PRIVATE;}
 230 <CLASS_CODE_I>argument  {yylval.line = line_no; return ARGUMENT;}
 231 <CLASS_CODE_I>virtual   {yylval.line = line_no; return VIRTUAL;}
 232 <CLASS_CODE_I>signal    {yylval.line = line_no; return SIGNAL;}
 233 <CLASS_CODE_I>override  {yylval.line = line_no; return OVERRIDE;}
 234 <CLASS_CODE_I>onerror   {return ONERROR;}
 235 <CLASS_CODE_I>0|[1-9][0-9]*|0x[0-9a-fA-F]+|0[0-7]+|[0-9]*\.[0-9]+|\.[0-9][0-9]* {
 236                         yylval.id = g_strdup(yytext);
 237                         return NUMBER;
 238                 }
 239 <CLASS_CODE,CLASS_CODE_I>:?[A-Za-z_][A-Za-z0-9_]*(:[A-Za-z0-9_]*)+      {
 240                         yylval.id = g_strdup(yytext);
 241                         return TYPETOKEN;
 242                 }
 243 <CLASS_CODE,CLASS_CODE_I>[A-Za-z_][A-Za-z0-9_]* {
 244                         yylval.id = g_strdup(yytext);
 245                         return TOKEN;
 246                 }
 247
 248 <CLASS_CODE>\{  {
 249                         BEGIN(CLASS_CODE_I);
 250                         return '{';
 251                 }
 252 <CLASS_CODE_I>\{        {
 253                         BEGIN(C_CODE);
 254                         parenth_depth=1;
 255                         class_after_c = TRUE;
 256                         ccode_line = line_no;
 257                         yylval.line = line_no;
 258                         return '{';
 259                 }
 260 <CLASS_CODE_I>\}        {
 261                                 BEGIN(INITIAL);
 262                                 return '}';
 263                         }
 264
 265 <CLASS_CODE,CLASS_CODE_I,INITIAL>[\t ]  ;  /*ignore*/
 266
 267 <*>.            {
 268                         yylval.line = line_no;
 269                         return yytext[0];
 270                 }
 271
 272 <*>[\n\r]       ;  /*ignore*/