tests/test_ffi_c_operators.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2011-2014 Alexis Laferrière <alexis.laf@xymus.net>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 class A
  18         var value : Int
  19
  20         init ( value : Int ) do self.value = value
  21
  22         fun +( other : A ) : A import value, A `{
  23                 int s = A_value( recv );
  24                 int o = A_value( other );
  25
  26                 return new_A( s + o );
  27         `}
  28
  29         fun +: A import value, A `{
  30                 int s = A_value(recv);
  31                 return new_A(+s);
  32         `}
  33
  34         fun -( other : A ) : A import value, A `{
  35                 int s = A_value( recv );
  36                 int o = A_value( other );
  37
  38                 return new_A( s - o );
  39         `}
  40
  41         fun -: A import value, A `{
  42                 int s = A_value(recv);
  43                 return new_A(-s);
  44         `}
  45
  46         fun *( by : Int ) : A import value, A `{
  47                 int s = A_value( recv );
  48
  49                 return new_A( s * by );
  50         `}
  51
  52         fun /( by : Int ) : A import value, A `{
  53                 int s = A_value( recv );
  54
  55                 return new_A( s / by );
  56         `}
  57
  58         redef fun ==( other ) import value, nullable Object.as(A) `{
  59                 if ( nullable_Object_is_a_A( other ) &&
  60                          A_value( nullable_Object_as_A(other) ) == A_value( recv ) )
  61                         return 1;
  62                 else
  63                         return 0;
  64         `}
  65
  66         fun %( other : A ) : A import value, A `{
  67                 return new_A( A_value( recv ) % A_value( other ) );
  68         `}
  69
  70 #       fun +=( other : A ) : A import value, value=, A `{
  71 #               int new_val = A_value( recv ) + A_value( other );
  72 #               A_value__assign( recv, new_val );
  73 #               return new_A( new_val );
  74 #       `}
  75
  76 #       fun -=( other : A ) : A import +=, A, value `{
  77 #               A inv_other = new_A( -1*A_value( other ) );
  78 #               return A__plus_equal( recv, int_other );
  79 #       `}
  80
  81         fun <=>( other : A ) : A import value, A `{
  82                 return new_A( A_value( recv )* 1024 );
  83         `}
  84
  85 #       fun @( other : A ) : A import value, A `{
  86 #               return new_A( A_value( recv )* 1000 );
  87 #       `}
  88
  89         fun >( other : A ) : Bool import value `{
  90                 return A_value( recv ) > A_value( other );
  91         `}
  92
  93         fun <( other : A ) : Bool import value `{
  94                 return A_value( recv ) < A_value( other );
  95         `}
  96
  97         fun >=( other : A ) : Bool import value `{
  98                 return A_value( recv ) >= A_value( other );
  99         `}
 100
 101         fun <=( other : A ) : Bool import value `{
 102                 return A_value( recv ) <= A_value( other );
 103         `}
 104
 105         fun >>( other : A ): A import value, value=, A `{
 106                 int new_val = A_value( recv ) >> A_value( other );
 107                 A_value__assign( recv, new_val );
 108                 return recv;
 109         `}
 110
 111         fun <<( other : A ): A import value, A `{
 112                 int new_val = A_value( recv ) << A_value( other );
 113                 A_value__assign( recv, new_val );
 114                 return recv;
 115         `}
 116
 117         fun []( index : Int ) : A import A `{
 118                 return new_A( index );
 119         `}
 120
 121         fun []=( index : Int, value : A ) : A import A `{
 122                 return new_A( index + A_value( value ) );
 123         `}
 124
 125         redef fun to_s do return value.to_s
 126 end
 127
 128 print new A( 1 ) + new A( 10 ) # 11
 129 print new A( 10 ) - new A( 1 ) # 9
 130
 131 print new A( 2 ) * 11 # 22
 132 print new A( 33 ) / 11 # 3
 133
 134 #print new A( 44 ) == null # false
 135 print new A( 55 ) == 55 # false
 136 print new A( 33 ) == new A( 11 ) # false
 137 print new A( 22 ) == new A( 77 ) # false
 138 print new A( 11 ) == new A( 11 ) # true
 139
 140 print new A( 147 ) % new A( 12 ) # 3
 141 print new A( 4 ) <=> new A( 123 ) # 4096
 142
 143 print new A( 1 ) < new A( 100 ) # true
 144 print new A( 100 ) < new A( 100 ) # false
 145 print new A( 100 ) < new A( 1 ) # false
 146
 147 print new A( 1 ) > new A( 100 ) # false
 148 print new A( 100 ) > new A( 100 ) # false
 149 print new A( 100 ) > new A( 1 ) # true
 150
 151 print new A( 1 ) <= new A( 100 ) # true
 152 print new A( 100 ) <= new A( 100 ) # true
 153 print new A( 100 ) <= new A( 1 ) # false
 154
 155 print new A( 1 ) >= new A( 100 ) # false
 156 print new A( 100 ) >= new A( 100 ) # true
 157 print new A( 100 ) >= new A( 1 ) # true
 158
 159 var x = new A( 1 )
 160 x = x << new A( 5 )
 161 print x # 32
 162
 163 var y = new A( 32 )
 164 y = y >> new A( 2 )
 165 print y # 8
 166
 167 var a = new A( 456 )
 168 print a[ 52 ] # 52
 169
 170 a[ 74 ] = new A( 96 )
 171 print a # 96
 172
 173 print(+(new A(123)))
 174 print(-(new A(123)))