plugins/am-project/ac-scanner.l

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * ac-scanner.l
   4  * Copyright (C) Sébastien Granjoux 2009 <seb.sfo@free.fr>
   5  *
   6  * main.c is free software: you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * main.c is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14  * See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 %{
  21
  22 #include "ac-scanner.h"
  23 #include "ac-parser.h"
  24
  25 #include "libanjuta/anjuta-debug.h"
  26 #include "libanjuta/anjuta-token-stream.h"
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #define YY_INPUT(buffer, result, max_size) result = anjuta_token_stream_read (yyextra->stream, buffer, max_size)
  32
  33 #define YY_EXTRA_TYPE  AmpAcScanner*
  34
  35 #define YY_DECL static int ac_yylex (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner)
  36
  37 //#define YY_USER_INIT {yy_flex_debug = 1;}
  38
  39 static gint amp_ac_scanner_parse_end (AmpAcScanner *scanner);
  40
  41 #define RETURN(tok) *yylval = anjuta_token_stream_tokenize (yyextra->stream, tok, yyleng); \
  42                     return tok
  43
  44 struct _AmpAcScanner
  45 {
  46     yyscan_t scanner;
  47
  48     AnjutaTokenStream *stream;
  49
  50     AmpProject *project;
  51
  52     AnjutaToken *parsed;
  53
  54         gboolean eof;           /* TRUE to emit EOF at the end */
  55
  56         GHashTable *variables;
  57 };
  58
  59
  60 %}
  61
  62 %option reentrant stack noyywrap yylineno
  63
  64 /* Remove some warnings */
  65 %option nounput noinput noyy_pop_state noyy_top_state
  66
  67 %option prefix="amp_ac_yy"
  68
  69 /* Necessary because autotools wrapper always looks for a file named "lex.yy.c",
  70  * not "lex.amp_ac_yy.c"
  71 %option outfile="lex.yy.c"*/
  72
  73 %option bison-bridge bison-locations
  74
  75 %option never-interactive
  76
  77 %option batch
  78
  79 %option debug
  80
  81 WS          [ \t\r\v]+
  82 NL          \n
  83 WSNL        [ \t\v\r\n]+
  84 COMMENT     #
  85 OPENM4QUOTE   \[
  86 CLOSEM4QUOTE  \]
  87 SINGLEQUOTE   \'
  88 DOUBLEQUOTE             \"
  89 OPENPARG   \(
  90 CLOSEPARG  \)
  91 COMMA       ,
  92 EQUAL       =
  93 LOWER       <
  94 GREATER     >
  95 NAME        [A-Za-z_][A-Za-z0-9_]*
  96 VARIABLE    $[A-Za-z_0-9]+
  97 OTHER       [^ \t\r\v\n#\[\]\"\'\\(),=><$_A-Za-z_]+
  98
  99 %x SPACE_LIST
 100
 101 %%
 102
 103 {WS}                    { RETURN (SPACE); }
 104
 105 \\\n                    { RETURN (SPACE); }
 106
 107 {NL}                    { RETURN (END_OF_LINE); }
 108
 109 {COMMENT}               { RETURN (HASH); }
 110
 111 {OPENM4QUOTE}             { RETURN (LEFT_BRACE); }
 112
 113 {CLOSEM4QUOTE}            { RETURN (RIGHT_BRACE); }
 114
 115 {OPENPARG}              { RETURN (LEFT_PAREN); }
 116
 117 {CLOSEPARG}             { RETURN (RIGHT_PAREN); }
 118
 119 {SINGLEQUOTE}                   { RETURN (SINGLE_QUOTE); }
 120
 121 {DOUBLEQUOTE}                   { RETURN (DOUBLE_QUOTE); }
 122
 123 {COMMA}                 { RETURN (COMMA); }
 124
 125 {EQUAL}                 { RETURN (EQUAL); }
 126
 127 {LOWER}                 { RETURN (LOWER); }
 128
 129 {GREATER}                 { RETURN (GREATER); }
 130
 131 dnl                     { RETURN (DNL); }
 132
 133 m4_include\(                    { RETURN (M4_INCLUDE); }
 134
 135 AC_ARG_ENABLE\(                 { RETURN (AC_ARG_ENABLE);}
 136
 137 AC_C_CONST                              { RETURN (AC_C_CONST);}
 138
 139 AC_CHECK_FUNCS\(                { RETURN (AC_CHECK_FUNCS);}
 140
 141 AC_CHECK_HEADERS\(              { RETURN (AC_CHECK_HEADERS);}
 142
 143 AC_CHECK_LIB\(                  { RETURN (AC_CHECK_LIB);}
 144
 145 AC_CHECK_PROG\(                 { RETURN (AC_CHECK_PROG);}
 146
 147 AC_CONFIG_FILES\(       { RETURN (AC_CONFIG_FILES); }
 148
 149 AC_CONFIG_HEADERS\(             { RETURN (AC_CONFIG_HEADERS); }
 150
 151 AC_CONFIG_MACRO_DIR\(   { RETURN (AC_CONFIG_MACRO_DIR); }
 152
 153 AC_CONFIG_SRCDIR\(              { RETURN (AC_CONFIG_SRCDIR); }
 154
 155 AC_EGREP_HEADER\(               { RETURN (AC_EGREP_HEADER); }
 156
 157 AC_EXEEXT                               { RETURN (AC_EXEEXT); }
 158
 159 AC_HEADER_STDC                  { RETURN (AC_HEADER_STDC); }
 160
 161 AC_INIT\(               { RETURN (AC_INIT); }
 162
 163 AC_OBJEXT                               { RETURN (AC_OBJEXT); }
 164
 165 AC_OUTPUT\(             { RETURN (OBSOLETE_AC_OUTPUT); }
 166
 167 AC_OUTPUT               { RETURN (AC_OUTPUT); }
 168
 169 AC_PREREQ\(                             { RETURN (AC_PREREQ); }
 170
 171 AC_PROG_CC                              { RETURN (AC_PROG_CC);}
 172
 173 AC_PROG_CPP                             { RETURN (AC_PROG_CPP);}
 174
 175 AC_PROG_CXX                             { RETURN (AC_PROG_CXX);}
 176
 177 IT_PROG_INTLTOOL\(              { RETURN (IT_PROG_INTLTOOL);}
 178
 179 AC_PROG_LEX                             { RETURN (AC_PROG_LEX);}
 180
 181 AC_PROG_LIBTOOL                 { RETURN (AC_PROG_LIBTOOL);}
 182
 183 AC_PROG_RANLIB                  { RETURN (AC_PROG_RANLIB);}
 184
 185 AC_PROG_YACC                    { RETURN (AC_PROG_YACC);}
 186
 187 AC_SUBST\(                              { RETURN (AC_SUBST);}
 188
 189 AC_TYPE_SIZE_T                  { RETURN (AC_TYPE_SIZE_T);}
 190
 191 AC_TYPE_OFF_T                   { RETURN (AC_TYPE_OFF_T);}
 192
 193 AM_INIT_AUTOMAKE\(              { RETURN (AM_INIT_AUTOMAKE);}
 194
 195 AM_GLIB_GNU_GETTEXT\(   { RETURN (AM_GLIB_GNU_GETTEXT);}
 196
 197 AM_MAINTAINER_MODE              { RETURN (AM_MAINTAINER_MODE);}
 198
 199 AM_PROG_LIBTOOL                 { RETURN (AM_PROG_LIBTOOL);}
 200
 201 LT_INIT\(                               { RETURN (LT_INIT);}
 202
 203 LT_INIT                                 { RETURN (DEFAULT_LT_INIT);}
 204
 205 LT_PREREQ\(                             { RETURN (LT_PREREQ);}
 206
 207 PKG_CHECK_MODULES\(     { RETURN (PKG_CHECK_MODULES); }
 208
 209 PKG_PROG_PKG_CONFIG\(   { RETURN (PKG_PROG_PKG_CONFIG);}
 210
 211 {NAME}                  { RETURN (NAME); }
 212
 213 {VARIABLE}              { RETURN (VARIABLE); }
 214
 215 {OTHER}|\$|\\           { RETURN (WORD); }
 216
 217 <<EOF>>                     { if (amp_ac_scanner_parse_end (yyextra) == YY_NULL) return YY_NULL; }
 218
 219 <SPACE_LIST>{
 220
 221 {WSNL}                    { RETURN (SPACE); }
 222
 223 \\\n                    { RETURN (SPACE); }
 224
 225 =|<|>|<=|>=             { RETURN (OPERATOR); }
 226
 227 {NAME}                    { RETURN (WORD); }
 228
 229 .                           {RETURN (WORD);}
 230 }
 231
 232 %%
 233
 234 /* Private functions
 235  *---------------------------------------------------------------------------*/
 236
 237
 238 static gint
 239 amp_ac_scanner_parse_end (AmpAcScanner *scanner)
 240 {
 241
 242         if (scanner->stream == NULL)
 243         {
 244                 yyterminate();
 245         }
 246         else
 247         {
 248                 if (scanner->eof)
 249                 {
 250                         scanner->eof = FALSE;
 251                         return END_OF_FILE;
 252                 }
 253
 254                 yypop_buffer_state(scanner->scanner);
 255         scanner->stream = anjuta_token_stream_pop (scanner->stream);
 256
 257                 if (scanner->stream == NULL)
 258                 {
 259                         yyterminate();
 260                 }
 261                 else
 262                 {
 263                         scanner->eof = anjuta_token_stream_get_current_file (scanner->stream) != NULL;
 264
 265                         /* Continue parsing the parent file */
 266                         return 1;
 267                 }
 268         }
 269 }
 270
 271 /* Parser functions
 272  *---------------------------------------------------------------------------*/
 273
 274 void
 275 amp_ac_yyerror (YYLTYPE *loc, AmpAcScanner *scanner, char const *s)
 276 {
 277     AnjutaTokenFileLocation location;
 278
 279     if (amp_project_get_token_location (scanner->project, &location, *loc))
 280     {
 281         g_message ("%s:%d.%d %s\n", location.filename, location.line, location.column, s);
 282         g_free (location.filename);
 283     }
 284     else
 285     {
 286         g_message ("%s \n", s);
 287     }
 288 }
 289
 290 void
 291 amp_ac_scanner_load_module (AmpAcScanner *scanner, AnjutaToken *module)
 292 {
 293     amp_project_load_module (scanner->project, module);
 294 }
 295
 296 void
 297 amp_ac_scanner_load_config (AmpAcScanner *scanner, AnjutaToken *list)
 298 {
 299     amp_project_load_config (scanner->project, list);
 300 }
 301
 302 void
 303 amp_ac_scanner_load_properties (AmpAcScanner *scanner, AnjutaToken *macro, AnjutaToken *list)
 304 {
 305     amp_project_load_properties (scanner->project, macro, list);
 306 }
 307
 308 void
 309 amp_ac_scanner_include (AmpAcScanner *scanner, AnjutaToken *list)
 310 {
 311         GFile *file;
 312         AnjutaTokenFile *include;
 313         AnjutaToken *token;
 314         AnjutaToken *name;
 315         gchar *filename;
 316
 317         name = anjuta_token_first_item (list);          /* m4_include macro */
 318         name = anjuta_token_next_item (name);           /* arguments list */
 319         name = anjuta_token_first_item (name);          /* filename */
 320         filename = g_strstrip (anjuta_token_evaluate (name));
 321         //g_message ("read include =%s=", filename);
 322         file = g_file_resolve_relative_path (anjuta_token_stream_get_current_directory (scanner->stream), filename);
 323         g_free (filename);
 324         include = anjuta_token_file_new (file);
 325         token = anjuta_token_file_load (include, NULL);
 326         amp_ac_scanner_parse_token (scanner, list, token, 0, file, NULL);
 327         g_object_unref (file);
 328 }
 329
 330 void
 331 amp_ac_scanner_update_variable (AmpAcScanner *scanner, AnjutaToken *variable)
 332 {
 333         AnjutaToken *arg;
 334         char *name = NULL;
 335         AnjutaToken *value = NULL;
 336
 337         arg = anjuta_token_first_word (variable);
 338         name = g_strstrip (anjuta_token_evaluate (arg));
 339         value = anjuta_token_nth_word (variable, 2);
 340
 341         g_hash_table_insert (scanner->variables, name, value);
 342 }
 343
 344 void
 345 amp_ac_scanner_subst_variable (AmpAcScanner *scanner, AnjutaToken *list)
 346 {
 347         AnjutaToken *arg;
 348         char *name = NULL;
 349         AnjutaToken *value = NULL;
 350
 351         arg = anjuta_token_first_word (list);
 352         name = g_strstrip (anjuta_token_evaluate (arg));
 353         value = anjuta_token_nth_word (list, 2);
 354         if (value == NULL)
 355         {
 356                 value = g_hash_table_lookup (scanner->variables, name);
 357         }
 358
 359         amp_project_add_subst_variable (scanner->project, name, value);
 360 }
 361
 362
 363 /* Public functions
 364  *---------------------------------------------------------------------------*/
 365
 366 AnjutaToken *
 367 amp_ac_scanner_parse_token (AmpAcScanner *scanner, AnjutaToken *root, AnjutaToken *content, gint start, GFile *filename, GError **error)
 368 {
 369     AnjutaToken *first;
 370     AnjutaTokenStream *stream;
 371
 372     stream = anjuta_token_stream_push (scanner->stream, root, content, filename);
 373     first = anjuta_token_stream_get_root (stream);
 374
 375         scanner->eof = filename != NULL;
 376
 377     if (scanner->stream != NULL)
 378     {
 379         /* Parse an included file or a expanded variable */
 380
 381         scanner->stream = stream;
 382         yypush_buffer_state(yy_create_buffer(NULL, YY_BUF_SIZE, scanner->scanner), scanner->scanner);
 383     }
 384     else
 385     {
 386         amp_ac_yypstate *ps;
 387         gint status;
 388         YYSTYPE yylval_param;
 389         YYLTYPE yylloc_param;
 390
 391         scanner->stream = stream;
 392         ps = amp_ac_yypstate_new ();
 393
 394         yylval_param = NULL;
 395         yylloc_param = NULL;
 396         switch (start)
 397         {
 398         case AC_SPACE_LIST_STATE:
 399             amp_ac_yypush_parse (ps, START_SPACE_LIST, &yylval_param, &yylloc_param, scanner);
 400             yy_push_state (SPACE_LIST, scanner->scanner);
 401             break;
 402         default:
 403             break;
 404         }
 405
 406         do
 407         {
 408             gint yychar = ac_yylex (&yylval_param, &yylloc_param, scanner->scanner);
 409
 410             yylloc_param = yylval_param;
 411             status = amp_ac_yypush_parse (ps, yychar, &yylval_param, &yylloc_param, scanner);
 412
 413         } while (status == YYPUSH_MORE);
 414         amp_ac_yypstate_delete (ps);
 415     }
 416
 417     return first;
 418 }
 419
 420 /* Constructor & Destructor
 421  *---------------------------------------------------------------------------*/
 422
 423 AmpAcScanner *
 424 amp_ac_scanner_new (AmpProject *project)
 425 {
 426         AmpAcScanner *scanner;
 427
 428         scanner = g_new0 (AmpAcScanner, 1);
 429
 430     yylex_init(&scanner->scanner);
 431     yyset_extra (scanner, scanner->scanner);
 432
 433     scanner->project = project;
 434
 435         scanner->variables = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify)g_free, NULL);
 436
 437         return scanner;
 438 };
 439
 440 void
 441 amp_ac_scanner_free (AmpAcScanner *scanner)
 442 {
 443         g_return_if_fail (scanner != NULL);
 444
 445         g_hash_table_remove_all (scanner->variables);
 446     yylex_destroy(scanner->scanner);
 447
 448         g_free (scanner);
 449 }