#-----------------------------------------------------------------------------*
#
#  @file gtl_debugger_parser.galgas
#
#  @section desc File description
#
#  Debugger parser for GTL.
#
#  @section copyright Copyright
#
#  GTL template language, 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_debugger_parser (gtl_debugger_scanner) {

#-----------------------------------------------------------------------------*
rule <gtl_expression>
  !@gtlExpression expression

rule <gtl_variable>
  !@gtlVarPath path

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  select
    $cont$
  or
    $continue$
  end
  instruction = @gtlContinueInstruction.new {
    !.here
    !""
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  $help$
  instruction = @gtlHelpInstruction.new {
    !.here
    !""
  }    
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  $step$
  instruction = @gtlStepInstruction.new {
    !.here
    !""
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  $load$
  let @lstring fileName
  select
    $identifier$ ?fileName
  or
    $string$ ?fileName
  end
  instruction = @gtlLoadInstruction.new {
    !.here
    !""
    !fileName
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  $hist$
  instruction = @gtlHistoryInstruction.new {
    !.here
    !""
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  $break$
  select
    $not$
    select
      $signed_literal_integer_bigint$ ?let @lbigint index
      instruction = @gtlBreakpointDeleteInstruction.new {
        !.here
        !""
        !index
      }
    or
      $all$
      instruction = @gtlBreakpointDeleteAllInstruction.new {
        !.here
        !""
      }      
    end
  or
    select 
      $identifier$ ?let @lstring fileName
      $.$
      $identifier$ ?let @lstring fileExtension
      $:$
      $signed_literal_integer_bigint$ ?let @lbigint lineNum
      instruction = @gtlBreakpointInstruction.new {
        !.here
        !""
        ![fileName string] + "." + fileExtension
        ![lineNum bigint]
      }
    or
      $signed_literal_integer_bigint$ ?let @lbigint lineNum
      instruction = @gtlBreakpointInstruction.new {
        !.here
        !""
        !""
        ![lineNum bigint]
      }
    end
  or
    $string$ ?let @lstring fileNameAndLineNum
    let @stringlist components = [[fileNameAndLineNum string] componentsSeparatedByString !":"]
    if [components length] == 2 then
      let @string fileName = [components mValueAtIndex !0]
      let @string lineNum = [components mValueAtIndex !1]
      instruction = @gtlBreakpointInstruction.new {
        !.here
        !""
        !fileName
        ![lineNum decimalUnsignedNumber]
      }
    else
      error .here : "Illegal breakpoint location" : instruction
    end
  or
    instruction = @gtlBreakpointListInstruction.new {
      !.here
      !""
    }
  end  
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  $watch$
  select
    $not$
    select
      $signed_literal_integer_bigint$ ?let @lbigint index
      instruction = @gtlWatchpointDeleteInstruction.new {
        !.here
        !""
        !index
      }
    or
      $all$
      instruction = @gtlWatchpointDeleteAllInstruction.new {
        !.here
        !""
      }      
    end
  or
    $($
    <gtl_expression> ?let @gtlExpression watchExpression
    instruction = @gtlWatchpointInstruction.new {
      !.here
      !""
      !watchExpression
    }
    $)$
  or
    instruction = @gtlWatchpointListInstruction.new {
      !.here
      !""
    }
  end  
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  
  $do$
  select
    <gtl_step_do_command> ?let @gtlInstruction instructionToStepDo
    instruction = @gtlDoInstInstruction.new {
      !.here
      !""
      !instructionToStepDo
    }
  or
    $not$
    select
      $signed_literal_integer_bigint$ ?let @lbigint num
      instruction = @gtlDoNotInstruction.new {
        !.here
        !""
        !num
      }
    or
      $all$
      instruction = @gtlDoNotAllInstruction.new {
        !.here
        !""
      }      
    end
  or
    instruction = @gtlDoInstruction.new {
      !.here
      !""
    }    
  end
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  instruction = @gtlStepInstruction.new {
    !.here
    !""
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  $let$
  <gtl_variable> ?let @gtlVarPath variable
  select
    $:=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetInstruction.new { 
      !.here
      !""
      !variable
      !expression
    } 
  or
    $+=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetAddInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $-=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetSubstractInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $*=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetMultiplyInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $/=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetDivideInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $mod=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetModuloInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $<<=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetShiftLeftInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $>>=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetShiftRightInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $&=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetAndInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $|=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetOrInstruction.new {
      !.here
      !""
      !variable
      !expression
    } 
  or
    $^=$
    <gtl_expression> ?let @gtlExpression expression
    instruction = @gtlLetXorInstruction.new {
      !.here
      !""
      !variable
      !expression
    }
  or
    instruction = @gtlLetUnconstructedInstruction.new {
      !.here
      !""
      !variable
    }
  end
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  $unlet$
  <gtl_variable> ?let @gtlVarPath variable
  instruction = @gtlUnletInstruction.new {
    !.here
    !""
    !variable
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_debugger_command>
  !@gtlInstruction instruction
{
  <gtl_step_do_command> ?instruction
}

#-----------------------------------------------------------------------------*
rule <gtl_step_do_command>
  !@gtlInstruction instruction
{
  $variables$
  instruction = @gtlVariablesInstruction.new {
    !.here
    !""
    !true
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_step_do_command>
  !@gtlInstruction instruction
{
  $display$
  <gtl_variable> ?let @gtlVarPath variable  
  instruction = @gtlDisplayStatementInstruction.new {
    !.here
    !""
    !variable
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_step_do_command>
  !@gtlInstruction instruction
{
  $print$ 
  <gtl_expression> ?let @gtlExpression expression
  instruction = @gtlPrintStatementInstruction.new {
    !.here
    !""
    !true
    !expression
  }
}

#-----------------------------------------------------------------------------*
rule <gtl_step_do_command>
  !@gtlInstruction instruction
{
  $list$
  @uint window = 5
  select 
    $signed_literal_integer_bigint$ ?let @lbigint num
    window = [[num bigint] uint]
    if window > 10 then window = 10 end
  or
  end
  instruction = @gtlListInstruction.new {
    !.here
    !""
    !window
  }
}

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

#-----------------------------------------------------------------------------*
# Instruction list in a setter, getter or function or any control instruction
#-----------------------------------------------------------------------------*
rule <gtl_step_do_command_list>
  !@gtlInstructionList instructionList
{
  instructionList = .emptyList

  repeat
  while
    <gtl_step_do_command> ?let @gtlInstruction instruction
    instructionList += !instruction
  end
}

}