src/mp-binary.c

   1 /*  Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
   2  *  Copyright (c) 2008-2009 Robert Ancell
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2, or (at your option)
   7  *  any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful, but
  10  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12  *  General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  17  *  02111-1307, USA.
  18  */
  19
  20 #include <stdio.h>
  21
  22 #include "mp.h"
  23 #include "mp-internal.h"
  24
  25 // FIXME: Make dynamic
  26 #define MAX_DIGITS 1000
  27
  28 static char digits[] = "0123456789ABCDEF";
  29
  30 static int hex_to_int(char digit)
  31 {
  32     if (digit >= '0' && digit <= '9')
  33         return digit - '0';
  34     if (digit >= 'A' && digit <= 'F')
  35         return digit - 'A' + 10;
  36     if (digit >= 'a' && digit <= 'f')
  37         return digit - 'a' + 10;
  38     return 0;
  39 }
  40
  41
  42 static void
  43 mp_bitwise(const MPNumber *x, const MPNumber *y, int (*bitwise_operator)(int, int), MPNumber *z, int wordlen)
  44 {
  45     char text1[MAX_DIGITS], text2[MAX_DIGITS], text_out[MAX_DIGITS], text_out2[MAX_DIGITS];
  46     int offset1, offset2, offset_out;
  47
  48     mp_cast_to_string(x, 16, 0, 0, text1, MAX_DIGITS);
  49     mp_cast_to_string(y, 16, 0, 0, text2, MAX_DIGITS);
  50     offset1 = strlen(text1) - 1 - strlen("₁₆");
  51     offset2 = strlen(text2) - 1 - strlen("₁₆");
  52     offset_out = wordlen / 4 - 1;
  53     if (offset_out <= 0) {
  54         offset_out = offset1 > offset2 ? offset1 : offset2;
  55     }
  56     if (offset_out > 0 && (offset_out < offset1 || offset_out < offset2)) {
  57         mperr("Overflow. Try a bigger word size");
  58         return;
  59     }
  60
  61     /* Perform bitwise operator on each character from right to left */
  62     for (text_out[offset_out+1] = '\0'; offset_out >= 0; offset_out--) {
  63         int v1 = 0, v2 = 0;
  64
  65         if (offset1 >= 0) {
  66             v1 = hex_to_int(text1[offset1]);
  67             offset1--;
  68         }
  69         if (offset2 >= 0) {
  70             v2 = hex_to_int(text2[offset2]);
  71             offset2--;
  72         }
  73         text_out[offset_out] = digits[bitwise_operator(v1, v2)];
  74     }
  75
  76     snprintf(text_out2, MAX_DIGITS, "%s₁₆", text_out);
  77     mp_set_from_string(text_out2, z);
  78 }
  79
  80
  81 static int mp_bitwise_and(int v1, int v2) { return v1 & v2; }
  82 static int mp_bitwise_or(int v1, int v2) { return v1 | v2; }
  83 static int mp_bitwise_xor(int v1, int v2) { return v1 ^ v2; }
  84 static int mp_bitwise_not(int v1, int dummy) { return v1 ^ 0xF; }
  85
  86
  87 bool
  88 mp_is_overflow (const MPNumber *x, int wordlen)
  89 {
  90     MPNumber tmp1, tmp2;
  91     mp_set_from_integer(2, &tmp1);
  92     mp_xpowy_integer(&tmp1, wordlen, &tmp2);
  93     return mp_is_greater_than (&tmp2, x);
  94 }
  95
  96
  97 void
  98 mp_and(const MPNumber *x, const MPNumber *y, MPNumber *z)
  99 {
 100     if (!mp_is_positive_integer(x) || !mp_is_positive_integer(y))
 101     {
 102         /* Translators: Error displayed when boolean AND attempted on non-integer values */
 103         mperr(_("Boolean AND is only defined for positive integers"));
 104     }
 105
 106     mp_bitwise(x, y, mp_bitwise_and, z, 0);
 107 }
 108
 109
 110 void
 111 mp_or(const MPNumber *x, const MPNumber *y, MPNumber *z)
 112 {
 113     if (!mp_is_positive_integer(x) || !mp_is_positive_integer(y))
 114     {
 115         /* Translators: Error displayed when boolean OR attempted on non-integer values */
 116         mperr(_("Boolean OR is only defined for positive integers"));
 117     }
 118
 119     mp_bitwise(x, y, mp_bitwise_or, z, 0);
 120 }
 121
 122
 123 void
 124 mp_xor(const MPNumber *x, const MPNumber *y, MPNumber *z)
 125 {
 126     if (!mp_is_positive_integer(x) || !mp_is_positive_integer(y))
 127     {
 128         /* Translators: Error displayed when boolean XOR attempted on non-integer values */
 129         mperr(_("Boolean XOR is only defined for positive integers"));
 130     }
 131
 132     mp_bitwise(x, y, mp_bitwise_xor, z, 0);
 133 }
 134
 135
 136 void
 137 mp_not(const MPNumber *x, int wordlen, MPNumber *z)
 138 {
 139     MPNumber temp;
 140
 141     if (!mp_is_positive_integer(x))
 142     {
 143         /* Translators: Error displayed when boolean XOR attempted on non-integer values */
 144         mperr(_("Boolean NOT is only defined for positive integers"));
 145     }
 146
 147     mp_set_from_integer(0, &temp);
 148     mp_bitwise(x, &temp, mp_bitwise_not, z, wordlen);
 149 }
 150
 151
 152 void
 153 mp_mask(const MPNumber *x, int wordlen, MPNumber *z)
 154 {
 155     char text[MAX_DIGITS];
 156     size_t len, offset;
 157
 158     /* Convert to a hexadecimal string and use last characters */
 159     mp_cast_to_string(x, 16, 0, 0, text, MAX_DIGITS);
 160     len = strlen(text) - strlen("₁₆");
 161     offset = wordlen / 4;
 162     offset = len > offset ? len - offset: 0;
 163     mp_set_from_string(text + offset, z);
 164 }
 165
 166
 167 void
 168 mp_shift(const MPNumber *x, int count, MPNumber *z)
 169 {
 170     int i, multiplier = 1;
 171
 172     if (!mp_is_integer(x)) {
 173         /* Translators: Error displayed when bit shift attempted on non-integer values */
 174         mperr(_("Shift is only possible on integer values"));
 175         return;
 176     }
 177
 178     if (count >= 0) {
 179         for (i = 0; i < count; i++)
 180             multiplier *= 2;
 181         mp_multiply_integer(x, multiplier, z);
 182     }
 183     else {
 184         MPNumber temp;
 185         for (i = 0; i < -count; i++)
 186             multiplier *= 2;
 187         mp_divide_integer(x, multiplier, &temp);
 188         mp_integer_component(&temp, z);
 189     }
 190 }
 191
 192
 193 void
 194 mp_ones_complement(const MPNumber *x, int wordlen, MPNumber *z)
 195 {
 196     MPNumber t;
 197     mp_set_from_integer(0, &t);
 198     mp_bitwise(x, &t, mp_bitwise_xor, z, wordlen);
 199     mp_not(z, wordlen, z);
 200 }
 201
 202
 203 void
 204 mp_twos_complement(const MPNumber *x, int wordlen, MPNumber *z)
 205 {
 206     mp_ones_complement (x, wordlen, z);
 207     mp_add_integer (z, 1, z);
 208 }