Skip to content
Snippets Groups Projects
  1. Jun 09, 2008
    • Erwan Jahier's avatar
      Use type_eff_ext everywhere I was using type_eff (and rename · 00c67618
      Erwan Jahier authored
      type_eff_ext into type_eff btw). The  rationale is to be able to type
      alias           on           polymorphic          nodes           (cf
      test/should_fail/semantics/bad_call03.lus,  that now  have  a correct
      error msg).  It also makes  to code more compact (no more translation
      from one  to the  other), and more  general (type_eff_ext  being more
      general than type_eff).  User polymorphic nodes should be easy now.
      
      move all the code in parsey.mly into parserUtil.ml (ease the debug).
      00c67618
  2. Jun 06, 2008
  3. Jun 05, 2008
  4. Jun 03, 2008
    • Erwan Jahier's avatar
    • Erwan Jahier's avatar
      Wrap the parser output with a new function, · e64e1031
      Erwan Jahier authored
      SolveIdent.recognize_predef_op  that  replaces  node call  by  Predef
      constructor  when   necessary,  via  a  complete   traversal  of  the
      SyntaxTree (instead  of doing it  in the parser). The  rationales for
      this change are that:
      
      - it is quite tedious to do it in parser as multiple locations are involved
      - I did missed some locations
      - It makes the parser more focused on parsing issues
      - that traversal  is a first step  do deal with  idref solving (hence
       the name of the new module that contains that function
      
      Note that lsrc/test/should_work/fab_test/lecteur.lus was using
      "plus" as a variable ident, which raised an error, which
      e64e1031
  5. Jun 02, 2008
  6. May 30, 2008
  7. May 29, 2008
  8. May 28, 2008
  9. May 27, 2008
  10. May 26, 2008
    • Erwan Jahier's avatar
      Add error messages when one tries to alaias a polymporphic or a · de984fca
      Erwan Jahier authored
      overloaded operator.
      
      Moreover, do not try to check that int or real constant are ok. It is
      the role of the host language.
      de984fca
    • Erwan Jahier's avatar
      * mapred -> fillred · b3051f50
      Erwan Jahier authored
      b3051f50
    • Erwan Jahier's avatar
      I have complety rewritten the way predef operator typing is · b09c78c5
      Erwan Jahier authored
      performed. The resulting code is both more compact, and more general.
      
      It is more  general, since that predef operators  are now represented
      by  node_exp_eff, exactly as  user nodes.   Hence, all  the functions
      that were  operating on  user nodes via  node_exp_eff (such  as, node
      aliasing) works for free on predef op!
      
      In order to be able  to perform that generalisation, it was necessary
      to  extend sligthly  the data  structure used  to represent  the node
      profile in CompiledData.node_exp_eff with information indicating if a
      variable is polymorphic or overloaded.
      
      Not that, currently, polymorphic  or overloaded variables can only be
      introduced by predef  operators. But I think it would  be easy to add
      those notions for normal user nodes after this change.
      
      New non-reg files boolred now compiles. Those involving
      - boolred
      - alias on predef.op
      b09c78c5
  11. May 21, 2008
    • Erwan Jahier's avatar
      Add support to be able to use iterators in node aliases. · 65b93560
      Erwan Jahier authored
      Also, node aliased to other nodes were handled poorly: I was replacing
      in the syntax tree the node by its alias. Now, I really define
      the alias node using the aliases one.
      
      For instance,
      
          node toto(x:t) returns (y:t);
          let
            ...
           tel
           node titi = toto;
           node tutu(...) returns(...);
           let
              ...
      	z = titi(a);
           tel
      
      was compiled into
      
          node toto(x:t) returns (y:t);
          let
            ...
           tel
      
           node tutu(...) returns(...);
           let
              ...
      	z = toto(a);
           tel
      
      Now, I generate
      
           node toto(x:t) returns (y:t);
           let
             ...
           tel
           node titi(i1:t) returns (o1:t);
           let
             o1 =toto(i1);
           tel
           node tutu(...) returns(...);
           let
              ...
      	z = titi(a);
           tel
      
      which is equivalent, but closer to the original program.
      6.13.0
      65b93560
  12. May 20, 2008
  13. May 16, 2008
Loading