#-----------------------------------------------------------------------------*
#
#  @file gtl_parser.galgas
#
#  @section desc File description
#
#  Parsing of 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_parser (gtl_scanner) {

rule <gtl_expression>
  !@gtlExpression expression

rule <gtl_variable>
  !@gtlVarPath path

rule <gtl_variable_or_here>
  !@gtlVarPath variable
  !@bool hereInstead

rule <gtl_import>
  ?@gtlContext context
  ?!@library lib 

rule <gtl_simple_instruction>
  !@gtlInstruction instruction

rule <gtl_argument_list>
  !@gtlArgumentList arguments

#-----------------------------------------------------------------------------*
rule <gtl_start_symbol>
  ? @gtlContext         context
  ?!@library            lib
  ! @gtlInstructionList program
{
  repeat 
  while
    <gtl_import> !context !?lib
  end
  <gtl_template_instruction_list> ?program
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction_list> !@gtlInstructionList instructionList
{
  instructionList = .emptyList

  repeat
    let @string templateString = @string.retrieveAndResetTemplateString
    if templateString != "" then
      instructionList +=
        !@gtlTemplateStringInstruction.new{ 
          !.here
          !""
          !templateString
        }
    end
  while
    <gtl_template_instruction> ?let @gtlInstruction instruction
    instructionList += !instruction
  while
    <gtl_simple_instruction> ?let @gtlInstruction instruction
    instructionList += !instruction
  end
}

#-----------------------------------------------------------------------------*
# emit parsing. Syntax is:
# ! expression
#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  $!$ let @location where = .here
  <gtl_expression> ?let @gtlExpression expression
  
  instruction = @gtlEmitInstruction.new {
    !where
    !signature(!where)
    !expression
  }
}

#-----------------------------------------------------------------------------*
# write to parsing. Syntax is:
# write to <executable> expression :
#   ...
# end write
#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  @bool isExecutable = false
  $write$ let @location where = .here $to$
  select $executable$ isExecutable = true or end
  <gtl_expression> ?let @gtlExpression fileName
  $:$
  <gtl_template_instruction_list> ?let @gtlInstructionList instructionList
  $end$ $write$ 
  
  instruction = @gtlWriteToInstruction.new {
    !where
    !signature(!where)
    !fileName
    !isExecutable
    !instructionList
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  let @lstring prefix
  @bool ifExists = false
  @gtlInstructionList instructionList = .emptyList
  let @gtlExpression fileName
  @gtlExpressionList templateArguments = .emptyList
  @bool globalTemplate = true
  
  $template$ let @location where = .here
  select
    globalTemplate = false
    $($
    select
      repeat
        <gtl_expression> ?let @gtlExpression expression
        templateArguments += !expression
      while
        $,$
      end
    or end
    $)$
  or
  end
  select
    $if$ $exists$
    ifExists = true
    <gtl_file_name> ?fileName
    select
      $in$ $identifier$ ?prefix
    or prefix = .new { !"" !@location.here } end
    select
      $or$
      <gtl_template_instruction_list> ?instructionList
      $end$ $template$
    or end
  or
    <gtl_file_name> ?fileName
    select
      $in$ $identifier$ ?prefix
    or prefix = .new { !"" !@location.here } end
  end
  instruction = @gtlTemplateInstruction.new {
    !where
    !signature(!where)
    !prefix
    !fileName
    !ifExists
    !globalTemplate
    !templateArguments
    !instructionList
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  $?$ let @location where = .here
  <gtl_variable> ?let @gtlVarPath columnConstantName
  
  instruction = @gtlGetColumnInstruction.new {
    !where
    !signature(!where)
    !columnConstantName
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  @gtlThenElsifStatementList thenElsifList = .emptyList
  @gtlInstructionList elseList = .emptyList
  
  $if$ let @location where = .here
  repeat
    <gtl_expression> ?let @gtlExpression condition
    $then$
    <gtl_template_instruction_list> ?let @gtlInstructionList instructionList
    
    thenElsifList += !condition !instructionList
  while
    $elsif$
  end
#--- else
  select
    $else$
    <gtl_template_instruction_list> ?elseList
  or end
#---
  $end$
  $if$
  
  instruction = @gtlIfStatementInstruction.new {
    !where
    !signature(!where)
    !thenElsifList !elseList
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  @gtlInstructionList beforeList = .emptyList
  let @gtlInstructionList doList
  @gtlInstructionList betweenList = .emptyList
  @gtlInstructionList afterList = .emptyList
  let @lstring indexName
  let @lstring variableName
  
  $foreach$ let @location where = .here
  $identifier$ ?var @lstring keyName
  select
    $,$ $identifier$ ?variableName
  or
    variableName = keyName
    keyName = .new { !"" !where }
  end
  select
    $($ $identifier$ ?indexName $)$
  or
    indexName = .new { !"INDEX" !.here }
  end
  $in$
  <gtl_expression> ?let @gtlExpression iterable
#--- before block
  select
    $before$
    <gtl_template_instruction_list> ?beforeList
  or end
#--- do block
  $do$
  <gtl_template_instruction_list> ?doList
#--- between block
  select
    $between$
    <gtl_template_instruction_list> ?betweenList
  or end
#--- after block
  select
    $after$
    <gtl_template_instruction_list> ?afterList
  or end
#---
  $end$
  $foreach$
  
  instruction = @gtlForeachStatementInstruction.new {
    !where
    !signature(!where)
    !keyName
    !variableName 
    !indexName 
    !iterable 
    !beforeList 
    !betweenList
    !afterList
    !doList
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  let @gtlInstructionList doList
  @gtlInstructionList betweenList = .emptyList
  @gtlExpressionList  iterable = .emptyList 

  $for$ let @location where = .here
  if [option gtl_options.warnDeprecated value] then
    warning .here : "for var in expression, ..., expression is deprecated"
      fixit { replace "foreach var in @( expression, ..., expression )" }
  end
  $identifier$ ?let @lstring variableName
  $in$
  repeat
    <gtl_expression> ?let @gtlExpression expression
    iterable += !expression
  while
    $,$
  end
#--- Do block
  $do$
  <gtl_template_instruction_list> ?doList
#--- between block
  select
    $between$
    <gtl_template_instruction_list> ?betweenList
  or end
#---
  $end$
  $for$
  
  instruction = @gtlForStatementInstruction.new {
    !where
    !signature(!where)
    !variableName
    !iterable
    !betweenList
    !doList
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  @gtlInstructionList beforeList = .emptyList
  @gtlInstructionList betweenList = .emptyList
  @gtlInstructionList afterList = .emptyList
  @sint64 direction = 1
  
  $loop$ let @location where = .here

  @gtlExpression step = @gtlTerminal.new {
    !where !@gtlInt.new { !where !emptylstring() !1 }
  }

  $identifier$ ?let @lstring variableName
  $from$
  <gtl_expression> ?let @gtlExpression start
  select
  or
    $up$
  or
    $down$ direction = -1
  end
  $to$
  <gtl_expression>  ?let @gtlExpression stop
  select
    $step$
    <gtl_expression> ?step
  or end
#--- before block
  select
    $before$
    <gtl_template_instruction_list> ?beforeList
  or end
#--- do block
  $do$
  <gtl_template_instruction_list> ?let @gtlInstructionList doList
#--- between block
  select
    $between$
    <gtl_template_instruction_list> ?betweenList
  or end
#--- after block
  select
    $after$
    <gtl_template_instruction_list> ?afterList
  or end
#---
  $end$
  $loop$
  
  instruction = @gtlLoopStatementInstruction.new {
    !where
    !signature(!where)
    !variableName
    !start
    !stop
    !step
    !direction
    !beforeList
    !betweenList
    !afterList
    !doList
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  let @gtlExpression limit
  
  $repeat$ let @location where = .here
  select
    $($
    <gtl_expression> ?limit
    $)$
  or
    limit = @gtlTerminal.new {
      !.here !@gtlInt.new{ !.here !emptylstring() ![@uint.max{} bigint] }
    }
  end
  <gtl_template_instruction_list> ?let @gtlInstructionList continueList
  $while$
  <gtl_expression> ?let @gtlExpression condition
  $do$
  <gtl_template_instruction_list> ?let @gtlInstructionList doList
  $end$
  $repeat$
  
  instruction = @gtlRepeatStatementInstruction.new {
    !where
    !signature(!where)
    !limit
    !condition
    !continueList
    !doList
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_template_instruction> !@gtlInstruction instruction
{
  $input$ let @location where = .here
  <gtl_argument_list> ?let @gtlArgumentList arguments
  
  instruction = @gtlInputStatementInstruction.new {
    !where
    !signature(!where)
    !arguments
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_file_name>
  !@gtlExpression expression
{
  select
    $identifier$ ?let @lstring fileName
    expression = @gtlTerminal.new {
      !@location.here !@gtlString.new {
        ![fileName location] !emptylstring() ![fileName string]
      }
    }
  or
    $from$
    <gtl_expression> ?expression
  end
}

} # end of syntax