Code coverage for expr_not_equal.li

///////////////////////////////////////////////////////////////////////////////
//                             Lisaac Compiler                               //
//                                                                           //
//                   LSIIT - ULP - CNRS - INRIA - FRANCE                     //
//                                                                           //
//   This program is free software: you can redistribute it and/or modify    //
//   it under the terms of the GNU General Public License as published by    //
//   the Free Software Foundation, either version 3 of the License, or       //
//   (at your option) any later version.                                     //
//                                                                           //
//   This program is distributed in the hope that it will be useful,         //
//   but WITHOUT ANY WARRANTY; without even the implied warranty of          //
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           //
//   GNU General Public License for more details.                            //
//                                                                           //
//   You should have received a copy of the GNU General Public License       //
//   along with this program.  If not, see <http://www.gnu.org/licenses/>.   //
//                                                                           //
//                     http://isaacproject.u-strasbg.fr/                     //
///////////////////////////////////////////////////////////////////////////////
Section Header

  + name        := EXPR_NOT_EQUAL;

  - copyright   := "2003-2007 Benoit Sonntag";


  - author      := "Sonntag Benoit (bsonntag@loria.fr)";
  - comment     := "Not equal binary comparison expression.";

Section Inherit

  + parent_expr_binary_cmp:Expanded EXPR_BINARY_CMP;

Section Public

  - symbol:STRING_CONSTANT := "!=";

  //
  // Execute.
  //

  - exec left_cst:INTEGER_CST and right_cst:INTEGER_CST :EXPR <-
  //-- C1 != C2 -> TRUE/FALSE
  ( + result:PROTOTYPE_CST;

    (left_cst.value != right_cst.value).if {
      result := PROTOTYPE_CST.create position type (type_true.default);
    } else {
      result := PROTOTYPE_CST.create position type (type_false.default);
    };
    left_cst .remove;
    right_cst.remove;

    count_equal_const := count_equal_const + 1;

    result
  );

  - exec:EXPR <-
  //-- E != E -> FALSE
  //-- Expanded != NULL -> TRUE
  //-- intersection (type_set(E),type_set(E')) = Empty -> TRUE
  ( + result:PROTOTYPE_CST;
    + r:PROTOTYPE_CST;
    + type_set_r,type_set_l:TYPES_TMP;

    (left ~= right).if {
      result := PROTOTYPE_CST.create position type (type_false.default);
      left .remove;
      right.remove;

      (left.static_type.raw = TYPE_NULL).if {
        count_equal_null := count_equal_null + 1;
      } else {
        count_equal_ident := count_equal_ident + 1;
      };

    } else {
      r ?= right;
      (
	(r != NULL)   
	{r.static_type.raw = TYPE_NULL}   
	{left.static_type.is_expanded}    
	{left.static_type.raw != type_pointer}
      ).if {
        left .remove;
        right.remove;
        result := PROTOTYPE_CST.create position type (type_true.default);

        count_equal_const := count_equal_const + 1;

      }.elseif {(! left.static_type.is_expanded)    {! right.static_type.is_expanded}} then {
        type_set_l := TYPES_TMP.new;
        left.get_type type_set_l;
        type_set_r := TYPES_TMP.new;
        right.get_type type_set_r;
        (
          (type_set_l.count = 1)            {type_set_r.count = 1}   
          {type_set_l.first = TYPE_NULL}    {type_set_r.first = TYPE_NULL}
        ).if {
          left .remove;
          right.remove;
          result := PROTOTYPE_CST.create position type (type_false.default);

          count_equal_null := count_equal_null + 1;

        }.elseif {type_set_l.intersection_is_empty type_set_r} then {
          left .remove;
          right.remove;
          result := PROTOTYPE_CST.create position type (type_true.default);

          count_equal_inter := count_equal_inter + 1;

        };
        type_set_l.free;
        type_set_r.free;
      };
    };

    result
  );

  //
  // Genere
  //

  - genere buffer:STRING <- // BSBS: a factoriser avec EXPR_EQUAL
  (

    count_equal_gener := count_equal_gener + 1;

    (
      (left.static_type.is_expanded)    
      {right.static_type.is_expanded}   
      {right.static_type.raw.type_c = NULL}
    ).if {
      buffer.append "(memcmp(";
      (left.static_type.is_expanded_ref).if_false {
        buffer.add_last ' ';
      };
      left.genere buffer;
      buffer.add_last ',';
      (right.static_type.is_expanded_ref).if_false {
        buffer.add_last ' ';
      };
      right.genere buffer;
      buffer.append ",sizeof(";
      left.static_type.raw.put_expanded_declaration buffer;
      buffer.append ")) != 0)";
    } else {
      parent_expr_binary_cmp.genere buffer;
    };
  );