#---------------------------------------------------------------------------*
#
#  @file gtl_expression_parser.galgas
#
#  @section desc File description
#
#  Expressions parser for GTL.
#
#  @section copyright Copyright
#
#  Goil OIL compiler, part of Trampoline RTOS
#
#  Trampoline is copyright (c) CNRS, University of Nantes,
#  Ecole Centrale de Nantes
#  Trampoline is protected by the French intellectual property law.
#
#  This software is distributed under the GNU Public Licence V2.
#  Check the LICENSE file in the root directory of Trampoline
#
#  $Date$
#  $Rev$
#  $Author$
#  $URL$
#
#---------------------------------------------------------------------------*

syntax gtl_expression_parser (gtl_scanner) {

#------------------------------------------------------------------------------*
#   E X P R E S S I O N                                                        *
#------------------------------------------------------------------------------*

rule <gtl_expression>
  !@gtlExpression expression
{
  <gtl_relation_term> ?expression
  repeat
  while
    $|$ let @location opLocation = .here
    <gtl_relation_term> ?let @gtlExpression rightSon
    expression = @gtlOrExpression.new { !opLocation !expression !rightSon }
  while
    $^$ let @location opLocation = .here
    <gtl_relation_term> ?let @gtlExpression rightSon
    expression = @gtlXorExpression.new { !opLocation !expression !rightSon }
  end
}

#------------------------------------------------------------------------------*
#   R E L A T I O N    T E R M                                                 *
#------------------------------------------------------------------------------*

rule <gtl_relation_term>
  !@gtlExpression expression
{
  <gtl_relation_factor> ?expression
  repeat
  while
    $&$ let @location opLocation = .here
    <gtl_relation_factor> ?let @gtlExpression rightSon
    expression = @gtlAndExpression.new { !opLocation !expression !rightSon }
  end
}

#------------------------------------------------------------------------------*
#   R E L A T I O N    F A C T O R                                             *
#------------------------------------------------------------------------------*

rule <gtl_relation_factor>
  !@gtlExpression expression
{
  <gtl_simple_expression> ?expression
  select
  or
    $==$ let @location opLocation = .here
    <gtl_simple_expression> ?let @gtlExpression rightSon
    expression = @gtlEqualExpression.new {
      !opLocation !expression !rightSon
    }
  or
    $!=$ let @location opLocation = .here
    <gtl_simple_expression> ?let @gtlExpression rightSon
    expression = @gtlNotEqualExpression.new {
      !opLocation !expression !rightSon
    }
  or
    $<=$ let @location opLocation = .here
    <gtl_simple_expression> ?let @gtlExpression rightSon
    expression = @gtlLowerOrEqualExpression.new {
      !opLocation !expression !rightSon
    }
  or
    $>=$ let @location opLocation = .here
    <gtl_simple_expression> ?let @gtlExpression rightSon
    expression = @gtlGreaterOrEqualExpression.new {
      !opLocation !expression !rightSon
    }
  or
    $>$ let @location opLocation = .here
    <gtl_simple_expression> ?let @gtlExpression rightSon
    expression = @gtlGreaterThanExpression.new {
      !opLocation !expression !rightSon
    }
  or
    $<$ let @location opLocation = .here
    <gtl_simple_expression> ?let @gtlExpression rightSon
    expression = @gtlLowerThanExpression.new {
      !opLocation !expression !rightSon
    }
  end
}

#------------------------------------------------------------------------------*
#   S I M P L E    E X P R E S S I O N                                         *
#------------------------------------------------------------------------------*

rule <gtl_simple_expression>
  !@gtlExpression expression
{
  <gtl_term> ?expression
  repeat
  while 
    $<<$ let @location opLocation = .here
    <gtl_term> ?let @gtlExpression rightSon
    expression = @gtlShiftLeftExpression.new {
      !opLocation !expression !rightSon
    }
  while 
    $>>$ let @location opLocation = .here
    <gtl_term> ?let @gtlExpression rightSon
    expression = @gtlShiftRightExpression.new {
      !opLocation !expression !rightSon
    }
  while 
    $+$ let @location opLocation = .here
    <gtl_term> ?let @gtlExpression rightSon
    expression = @gtlAddExpression.new {
      !opLocation !expression !rightSon
    }
  while 
    $.$ let @location opLocation = .here
    if [option gtl_options.warnDeprecated value] then
      warning opLocation : "'.' operator is deprecated" fixit { replace "+" }
    end
    <gtl_term> ?let @gtlExpression rightSon
    expression = @gtlAddExpression.new {
      !opLocation !expression !rightSon
    }
  while 
    $-$ let @location opLocation = .here
    <gtl_term> ?let @gtlExpression rightSon
    expression = @gtlSubstractExpression.new {
      !opLocation !expression !rightSon
    }
  end
}

#------------------------------------------------------------------------------*
#   T E R M                                                                    *
#------------------------------------------------------------------------------*

rule <gtl_term>
  !@gtlExpression expression
{
  <gtl_factor> ?expression
  repeat
  while 
    $*$ let @location opLocation = .here
    <gtl_factor> ?let @gtlExpression rightSon
    expression = @gtlMultiplyExpression.new {
      !opLocation !expression !rightSon
    }
  while 
    $/$ let @location opLocation = .here
    <gtl_factor> ?let @gtlExpression rightSon
    expression = @gtlDivideExpression.new {
      !opLocation !expression !rightSon
    }
  while 
    $mod$ let @location opLocation = .here
    <gtl_factor> ?let @gtlExpression rightSon
    expression = @gtlModulusExpression.new {
      !opLocation !expression !rightSon
    }
  end
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    ( EXPRESSION )                                         *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $($ let @location opLocation = .here
  <gtl_expression> ?let @gtlExpression factorExpression
  expression = @gtlParenthesizedExpression.new {
    !opLocation
    !factorExpression
  }
  $)$
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    not FACTOR                                             *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $not$ let @location opLocation = .here
  <gtl_factor> ?let @gtlExpression notExpression
  expression = @gtlNotExpression.new { !opLocation !notExpression }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    ~ FACTOR                                               *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $~$ let @location opLocation = .here
  <gtl_factor> ?let @gtlExpression notExpression
  expression = @gtlNotExpression.new { !opLocation !notExpression }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    - FACTOR                                               *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $-$ let @location opLocation = .here
  <gtl_factor> ?let @gtlExpression minusExpression
  expression = @gtlMinusExpression.new { !opLocation !minusExpression }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    + FACTOR                                               *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $+$ let @location opLocation = .here
  <gtl_factor> ?let @gtlExpression plusExpression
  expression = @gtlPlusExpression.new { !opLocation !plusExpression }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    true                                                   *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $yes$ let @location opLocation = .here
  expression = @gtlTerminal.new{
    !opLocation !@gtlBool.new { !opLocation !emptylstring() !true }
  }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    false                                                  *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $no$
  expression = @gtlTerminal.new{
    !.here !@gtlBool.new { !.here !emptylstring() !false }
  }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    an integer value                                       *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $signed_literal_integer_bigint$ ?let @lbigint literalInteger
  expression = @gtlTerminal.new{
    !.here !@gtlInt.new { !.here !emptylstring() ![literalInteger bigint] }
  }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    a float value                                          *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $literal_double$ ?let @ldouble literalFloat
  expression = @gtlTerminal.new{
    !.here !@gtlFloat.new { !.here !emptylstring() ![literalFloat double] }
  }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    a literal string value                                 *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $string$ ?let @lstring literalString
  expression = @gtlTerminal.new{
    !.here !@gtlString.new { !.here !emptylstring() ![literalString string] }
  }
}

#------------------------------------------------------------------------------*
#   F A C T O R    :    a literal char value                                 *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $literal_char$ ?let @lchar literalChar
  expression = @gtlTerminal.new{
    !.here !@gtlChar.new { !.here !emptylstring() ![literalChar char] }
  }
}

#------------------------------------------------------------------------------*
#                         F A C T O R                                          *
#   template getter call :   [expression getter : ... ]                        *
#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $[$
  <gtl_expression> ?let @gtlExpression target
  $identifier$ ?let @lstring getterName
  if [option gtl_options.warnDeprecated value] then
    if "stringByCapitalizingFirstCharacter" == getterName then
      warning getterName : "stringByCapitalizingFirstCharacter is deprecated"
        fixit { replace "capitalized" }
    end
  end
  @gtlExpressionList argumentList = .emptyList
  select
  or
    $:$
    repeat
      <gtl_expression> ?let @gtlExpression argument
      argumentList += !argument
    while
      $,$
    end
  end
  $]$
  expression = @gtlGetterCallExpression.new {
    !.here
    !target
    !getterName
    !argumentList
  }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  <gtl_variable> ?let @gtlVarPath path
  select
    expression = @gtlVarRef.new { !.here !path }
  or
    if [path length] > 1 then
      error .here : "illegal function name"
    end
    @gtlExpressionList functionArguments = .emptyList
    $($
    select
      repeat
        <gtl_expression> ?let @gtlExpression expression
        functionArguments += !expression
      while
        $,$
      end
    or end
    $)$
    let @lstring functionName = [path pathAsFunctionName]
    expression = @gtlFunctionCallExpression.new {
      !.here
      !functionName
      !functionArguments
    }
  end
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $exists$ <gtl_variable> ?let @gtlVarPath path
  select
    $default$
    $($
    <gtl_expression> ?let @gtlExpression defaultExpression
    $)$
    expression = @gtlExistsDefaultExpression.new {
      !.here !path !defaultExpression
    }
  or
    expression = @gtlExistsExpression.new { !.here !path }
  end
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $typeof$ <gtl_variable> ?let @gtlVarPath path
  expression = @gtlTypeOfExpression.new { !.here !path }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $true$
  expression = @gtlTerminal.new {
    !.here
    !@gtlBool.new { 
      !.here
      !emptylstring()
      !true
    }
  }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $false$
  expression = @gtlTerminal.new {
    !.here
    !@gtlBool.new { 
      !.here
      !emptylstring()
      !false
    }
  }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $literal_enum$ ?let @lstring enumValue
  expression = @gtlTerminal.new {
    !.here
    !@gtlEnum.new { 
      !.here
      !emptylstring()
      !enumValue
    }
  }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $@$ $identifier$ ?let @lstring typeName
  let @string name = [typeName string]
  let @gtlType type
  if    name == "int"    then
    type = .new { ![typeName location] !emptylstring() !`@gtlInt }
  elsif name == "float"  then
    type = .new { ![typeName location] !emptylstring() !`@gtlFloat }
  elsif name == "string" then
    type = .new { ![typeName location] !emptylstring() !`@gtlString }
  elsif name == "bool"   then
    type = .new { ![typeName location] !emptylstring() !`@gtlBool }
  elsif name == "struct" then
    type = .new { ![typeName location] !emptylstring() !`@gtlStruct }
  elsif name == "list"   then
    type = .new { ![typeName location] !emptylstring() !`@gtlList }
  elsif name == "map"    then
    type = .new { ![typeName location] !emptylstring() !`@gtlMap }
  elsif name == "enum"   then
    type = .new { ![typeName location] !emptylstring() !`@gtlEnum }
  elsif name == "type"   then
    type = .new { ![typeName location] !emptylstring() !`@gtlType }
  elsif name == "set"   then
    type = .new { ![typeName location] !emptylstring() !`@gtlSet }
  elsif name == "char"   then
    type = .new { ![typeName location] !emptylstring() !`@gtlChar }
  elsif name == "unconstructed"   then
    type = .new { ![typeName location] !emptylstring() !`@gtlUnconstructed }
  else error .here : name + " does not name a type" : type
  end
  expression = @gtlTerminal.new { ![typeName location] !type }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $emptylist$
  if [option gtl_options.warnDeprecated value] then
    warning .here : "emptylist is deprecated" fixit { replace "@( )" }
  end
  expression = @gtlTerminal.new {
    !.here
    !@gtlList.new { 
      !.here
      !emptylstring()
      !.emptyList
    }
  }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $emptymap$
  if [option gtl_options.warnDeprecated value] then
    warning .here : "emptymap is deprecated" fixit { replace "@[ ]" }
  end
  expression = @gtlTerminal.new {
    !.here
    !@gtlMap.new { 
      !.here
      !emptylstring()
      !.emptyMap
    }
  }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $mapof$
  <gtl_expression> ?let @gtlExpression data
  select
    $by$
    $identifier$ ?let @lstring key
    expression = @gtlMapOfListExpression.new {
      !.here
      !data
      !key
    }
  or 
    $end$
    expression = @gtlMapOfStructExpression.new {
      !.here
      !data
    }
  end
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $listof$
  <gtl_expression> ?let @gtlExpression data
  expression = @gtlListOfExpression.new { !.here !data }
  $end$
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $@($
  @gtlExpressionList expressionList = .emptyList
  select
    repeat
      <gtl_expression> ?let @gtlExpression listItem
      expressionList += !listItem
    while $,$
    end
  or
  end
  $)$
  expression = @gtlLiteralListExpression.new { !.here !expressionList }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $@[$
  @gtlExpressionMap expressionMap = .emptyMap
  select 
    repeat
      $string$ ?let @lstring key
      $:$
      <gtl_expression> ?let @gtlExpression mapItem
      [!?expressionMap put !key !mapItem]
    while $,$
    end
  or
  end
  $]$
  expression = @gtlLiteralMapExpression.new { !.here !expressionMap }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $@{$
  @gtlExpressionMap expressionMap = .emptyMap
  select
    repeat
      $identifier$ ?let @lstring fieldName
      $:$
      <gtl_expression> ?let @gtlExpression structField
      [!?expressionMap put !fieldName !structField]
    while $,$
    end
  or
  end
  $}$
  expression = @gtlLiteralStructExpression.new { !.here !expressionMap }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $@!$
  @gtlExpressionList expressionList = .emptyList
  select
    repeat
      <gtl_expression> ?let @gtlExpression setElement
      expressionList += !setElement
    while $,$
    end
  or
  end
  $!$
  expression = @gtlLiteralSetExpression.new { !.here !expressionList }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $@?$
  <gtl_expression> ?let @gtlExpression exp
  $?$
  expression = @gtlTerminal.new { !.here !@gtlExpr.new { !.here !emptylstring() !exp } }
}

#------------------------------------------------------------------------------*

rule <gtl_factor>
  !@gtlExpression expression
{
  $__VARS__$
  expression = @gtlAllVarsRef.new { !.here }
}

#------------------------------------------------------------------------------*

rule <gtl_variable>
  !@gtlVarPath path
{
  path = .emptyList
  repeat
    $identifier$ ?let @lstring variableName
    select
      $[$
      <gtl_expression> ?let @gtlExpression expression
      $]$
      path += !@gtlVarItemCollection.new { !variableName !expression }
      select
        $[$
        <gtl_expression> ?let @gtlExpression expression
        $]$
        path += !@gtlVarItemSubCollection.new { !.here !expression }
        repeat
        while
          $[$
          <gtl_expression> ?let @gtlExpression expression
          $]$
          path += !@gtlVarItemSubCollection.new { !.here !expression }
        end
      or
      end
    or
      path += !@gtlVarItemField.new { !variableName }
    end
  while
    $::$
  end
}

#------------------------------------------------------------------------------*

rule <gtl_variable_or_here>
  !@gtlVarPath path
  !@bool hereInstead
{
  select
    $here$ path = .emptyList
    hereInstead = true
  or
    <gtl_variable> ?path
    hereInstead = false
  end
}

#-----------------------------------------------------------------------------*
rule <gtl_argument_list>
  !@gtlArgumentList arguments
{
  arguments = .emptyList
  $($
  select
    repeat
      $identifier$ ?let @lstring argumentName
      select
        $:$ $@$ $identifier$ ?let @lstring typeName
        arguments += !true ![typeName gtlType] !argumentName
      or
        arguments += !false !`@gtlData !argumentName
      end
    while $,$ 
    end
  or end
  $)$
}

}