1. 15 Jun, 2018 1 commit
  2. 14 Jun, 2018 1 commit
  3. 07 Jun, 2018 2 commits
  4. 05 Jun, 2018 1 commit
  5. 04 Jun, 2018 1 commit
  6. 01 Jun, 2018 1 commit
  7. 31 May, 2018 2 commits
  8. 01 May, 2018 1 commit
    • Sylvain Dailler's avatar
      Tentatively add new error handling mode of menhir · 68532c3b
      Sylvain Dailler authored
      This commit tries to add the new parsing errors from menhir. It changes
      the lexer so that precise error made from the provided handcrafted.messages
      can be displayed on failure.
      Also fix #111
      
      * Makefile.in
      This adds a rule for src/parser/parser_messages.ml which either compile
      the messages or regenerates them. It needs regeneration when changes are
      added in .mly or .messages file. This also adds option .DELETE_ON_ERROR.
      
      * src/parser/lexer.mll
      The parser now uses loop_handle function from menhir (see menhir ref.
      manual).
      
      * src/parser/report.ml
      Added file from Compcert's preparser to report error from "checkpoint". It
      allows to use $0 notation in handcrafted.messages
      
      * src/parser/handcrafted.messages
      To be edited file for error messages.
      
      * bench/*
      Adding a parsing-bench for parsing errors following the model of ce-bench:
      an oracle is provided so that error messages are not lost.
      68532c3b
  9. 16 Apr, 2018 2 commits
  10. 11 Apr, 2018 1 commit
  11. 06 Apr, 2018 1 commit
  12. 21 Mar, 2018 1 commit
    • Guillaume Melquiond's avatar
      Homogenize constructor names. · 6ef0273e
      Guillaume Melquiond authored
      The pattern-matching construct in the logic is now systematically named
      "Tcase" in constructors (Ptree.Tmatch -> Tcase). The one in the
      programs (supporting exceptions) is now systematically named "Ematch"
      (Expr.Ecase -> Ematch, Dexpr.DEcase -> DEmatch). They are now homogeneous
      with the other constructors: Term.Tcase, Dterm.DTcase, Ptree.Ematch,
      Mltree.Ematch. Smart constructor Expr.e_case was renamed accordingly.
      6ef0273e
  13. 20 Mar, 2018 1 commit
  14. 21 Feb, 2018 2 commits
  15. 16 Feb, 2018 2 commits
  16. 14 Feb, 2018 2 commits
  17. 12 Jan, 2018 1 commit
  18. 11 Jan, 2018 1 commit
  19. 24 Dec, 2017 1 commit
  20. 13 Dec, 2017 1 commit
  21. 07 Dec, 2017 2 commits
  22. 22 Nov, 2017 1 commit
  23. 13 Jul, 2017 1 commit
  24. 05 Jul, 2017 1 commit
    • MARCHE Claude's avatar
      ITP: support for qualified ident and infix ident · bccdfacc
      MARCHE Claude authored
      command "search" and transformations taking idents as arguments now can
      support qualified idents and infix symbols.
      
      For example, "search (+) (*)" returns the distributivity axioms
      
      FIXME: "search Int.(+)" fails, probably missing namespaced for
      imported modules
      bccdfacc
  25. 22 Jun, 2017 1 commit
    • Andrei Paskevich's avatar
      WhyML: check type invariants · 15fc3d65
      Andrei Paskevich authored
      Type declarations for records (incuding the private records) can
      now be followed by a "witness": a set of values for the record
      fields that must satisfy the type invariant (if any). The fields
      must be initialized with pure terminating program expressions.
      The current syntax, proposed by Martin, is
      
          type t 'a = { f: ty1; g: ty2 }
            invariant { J[f,g] }
            by { f = e1; g = e2 }
      
      The generated proof obligation is the VC for
      
          let g = e2 in let f = e1 in assert { J[f,g] }
      
      In absence of an explicit witness, an existential proof obligation
      "exists f,g. J[f,g]" is produced.
      15fc3d65
  26. 16 Jun, 2017 2 commits
    • Andrei Paskevich's avatar
      alias specification: reviewed · f23ed837
      Andrei Paskevich authored
      f23ed837
    • Andrei Paskevich's avatar
      WhymL: break and continue · df239061
      Andrei Paskevich authored
      Without an argument, break and continue refer to the innermost loop.
      A label put over an expression sequence starting with a loop, can be
      used as an optional argument for break and continue:
      
        label L in
        [ghost] ["tag"] [M.begin]
          while true do
            ...
            break L
            ...
          done;
          [...]
        [end] [: unit]
      
      In the square brackets are listed the constructions allowed between
      the label declaration and the loop expression.
      df239061
  27. 14 Jun, 2017 1 commit
  28. 13 Jun, 2017 1 commit
    • Andrei Paskevich's avatar
      WhyML: white-box blocks · 516cfd3a
      Andrei Paskevich authored
      Just as abstract blocks, "white-box blocks" are program expressions
      with an additional contract attached to their execution place.
      Contrary to abstract blocks, whiteboxes do not hide their contents
      from the outer computation. In most cases, you would not need
      whiteboxes at all, as the same effect can be achieved by adding
      assertions. Their utility comes from their syntax: the added
      contract clauses bind to the expression and do not require
      additional semicolons, begin-end's, let-in's or try-with's.
      
      Compare:
      
          let x = <expr> in assert { P x }; x
      to  <expr> ensures { P result }
      or  <expr> returns { x -> P x }
      
          if ... then begin let x = <expr> in assert { P x }; x end; ...
      to  if ... then <expr> ensures { P result }; ...
      
          try <expr> with E x -> assert { P x }; raise E x; end
      to  <expr> raises { E x -> P x }
      
      Internally, whiteboxes are just abstract blocks (zero-argument
      anonymous functions executed in-place) with the label "vc:white_box"
      on top. The user never needs to write this label explicitly though.
      516cfd3a
  29. 11 Jun, 2017 2 commits
    • Andrei Paskevich's avatar
      WhyML: tuple terms/expressions do not require parentheses · a1e032f6
      Andrei Paskevich authored
      This makes the syntax cleaner and brings us closer to OCaml.
      
      One incompatibility with the previous grammar is that "ghost"
      binds stronger than the left arrow of assignment, and thus
      ghost assignments have to be written as "ghost (x.f <- v)".
      
      This is unavoidable, because assignment has to be weaker than
      the tuple comma (think "x.f, y.g <- y.g, x.f" or "a[i] <- u,v"),
      and "ghost" has to be stronger than comma, for consistency with
      our patterns and our return types.
      
      The "return" construction is weaker than comma, for "return a,b".
      It is also weaker than assignment, though "return x.f <- b" does
      not make much sense either way.
      
      This change does not concern type expressions, where a tuple
      type must always have its clothes^Wparentheses on: (int, int).
      It might be nice to write "constant pair: int, bool", but on
      the other hand this would break casts like "42: int, true".
      a1e032f6
    • Andrei Paskevich's avatar
      WhyML: match ... with exception ... end · 6aace661
      Andrei Paskevich authored
      6aace661
  30. 09 Jun, 2017 2 commits