/* Copyright (C) 2009 David Zeuthen <zeuthen@gmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Author: David Zeuthen <zeuthen@gmail.com>
 */

%{
#define YYDEBUG 1

#include <stdio.h>
#include <glib.h>
#include "libdbus_idl_1_la-idlparser.h"
#include "idl.h"

extern int yylex (DIParser *parser);
#define YY_DECL int yylex (DIParser *parser)

static DIComment *parse_comment (DIParser *parser);
static DIComment *parse_eol_comment (DIParser *parser);

static gchar *unescape_string (const gchar *str);
%}

%option nounput

stringtext              ([^\\\"])|(\\.)

%%

"/**"                   {yylval.comment = parse_comment (parser); return DOC_COMMENT;}
"///"                   {yylval.comment = parse_eol_comment (parser); yylineno++; return DOC_COMMENT;}
"/*"                    {parse_comment (parser);}
"//"			{parse_eol_comment (parser); yylineno++;}
"namespace"             {return NAMESPACE;}
"interface"             {return INTERFACE;}
"signal"                {return SIGNAL;}
"property"              {return PROPERTY;}
"struct"                {return STRUCT;}
"enum"                  {return ENUM;}
"error_domain"          {return ERROR_DOMAIN;}
"in"                    {return IN;}
"out"                   {return OUT;}
"readonly"              {return READONLY;}
"writeonly"             {return WRITEONLY;}
"byte"                  {return TYPE_BYTE;}
"int16"                 {return TYPE_INT16;}
"uint16"                {return TYPE_UINT16;}
"int32"                 {return TYPE_INT32;}
"uint32"                {return TYPE_UINT32;}
"int64"                 {return TYPE_INT64;}
"uint64"                {return TYPE_UINT64;}
"double"                {return TYPE_DOUBLE;}
"boolean"               {return TYPE_BOOLEAN;}
"string"                {return TYPE_STRING;}
"objpath"               {return TYPE_OBJECT_PATH;}
"signature"             {return TYPE_SIGNATURE;}
"array"                 {return TYPE_ARRAY;}
"dict"                  {return TYPE_DICT;}
"variant"               {return TYPE_VARIANT;}
"."                     {return DOT;}
","                     {return COMMA;}
";"                     {return SEMICOLON;}
[a-zA-Z_][a-zA-Z0-9_]*  {yylval.str = g_strdup (yytext); return IDENTIFIER;}
[0-9][0-9]*             {yylval.number = atoi (yytext); return NUMBER;}
"="                     {return EQUAL;}
"+"                     {return PLUS;}
"-"                     {return MINUS;}
"*"                     {return STAR;}
"/"                     {return SLASH;}
"&"                     {return AMPERSAND;}
"|"                     {return PIPE;}
"%"                     {return PERCENT;}
"{"                     {return OBRACE;}
"}"                     {return EBRACE;}
"("                     {return OPAREN;}
")"                     {return EPAREN;}
"<"                     {return OBRACKET;}
">"                     {return EBRACKET;}
"@"                     {return ATSIGN;}
"\""{stringtext}*"\""	{yylval.str = unescape_string (yytext) ; return STRING; }
[\r\n]                  { yylineno++; /* ignore end of line */ }
[ \t]+                  { /* ignore whitespace */ }
.                       {return UNKNOWN;}
%%


static DIComment *
parse_comment (DIParser *parser)
{
  DIComment *c;
  GString *comment;
  int c1, c2;

  c1 = input();
  c2 = input();

  comment = g_string_new ("");

  while (c2 != EOF && (c1 != '*' || c2 != '/'))
    {
      g_string_append_c (comment, c1);

      if (c1 == '\n')
        yylineno++;

      c1 = c2;
      c2 = input();
    }

  c = di_comment_new (g_strdup (parser->path_to_current_file),
                      yylineno,
                      TRUE,
                      comment->str);

  parser->comments = g_list_append (parser->comments, c);

  g_string_free (comment, FALSE);

  return c;
}

static DIComment *
parse_eol_comment (DIParser *parser)
{
  GString *comment;
  DIComment *c;
  int c1;

  c1 = input();
  comment = g_string_new ("");

  while (c1 != EOF && c1 != '\r' && c1 != '\n')
    {
      g_string_append_c (comment, c1);
      c1 = input ();
    }

  c = di_comment_new (g_strdup (parser->path_to_current_file),
                      yylineno,
                      FALSE,
                      comment->str);

  parser->comments = g_list_append (parser->comments, c);

  g_string_free (comment, FALSE);

  return c;
}

static gchar *
unescape_string (const gchar *str)
{
  gchar *ret;
  gchar *s;

  ret = g_strdup (str + 1);
  if (strlen (ret) == 0)
    goto out;
  ret[strlen (ret) - 1] = '\0';

  s = ret;
  ret = g_strcompress (ret);
  g_free (s);

out:
  return ret;
}