[hcoop/debian/mlton.git] / runtime / basis / Word / Word-check.h


#define WordS_addCheckBody(size, x, y, doOverflow, doSuccess)   \
  do {                                                          \
    if (x >= 0) {                                               \
      if (y > WordS##size##_max - x) {                          \
        doOverflow;                                             \
      }                                                         \
    } else if (y < WordS##size##_min - x) {                     \
      doOverflow;                                               \
    }                                                           \
    doSuccess;                                                  \
  } while (0)
#define WordS_addCheckBodyCX(size, c, x, doOverflow, doSuccess) \
WordS_addCheckBody(size, c, x, doOverflow, doSuccess)

#define WordU_addCheckBody(size, x, y, doOverflow, doSuccess)   \
  do {                                                          \
    if (y > Word##size##_max - x) {                             \
      doOverflow;                                               \
    }                                                           \
    doSuccess;                                                  \
  } while (0)
#define WordU_addCheckBodyCX(size, c, x, doOverflow, doSuccess) \
WordU_addCheckBody(size, c, x, doOverflow, doSuccess)

#define WordS_mulCheckBody(size, x, y, doOverflow, doSuccess)   \
  do {                                                          \
    if ((x == (WordS##size)0) || (y == (WordS##size)0)) {       \
    } else                                                      \
    if (x > (WordS## size)0) {                                  \
      if (y > (WordS##size)0) {                                 \
        if (x > WordS##size##_quot (WordS##size##_max, y)) {    \
          doOverflow;                                           \
        }                                                       \
      } else /* (y < (WordS##size)0) */ {                       \
        if (y < WordS##size##_quot (WordS##size##_min, x)) {    \
          doOverflow;                                           \
        }                                                       \
      }                                                         \
    } else /* (x < (WordS##size)0) */ {                         \
      if (y > (WordS##size)0) {                                 \
        if (x < WordS##size##_quot (WordS##size##_min, y)) {    \
          doOverflow;                                           \
        }                                                       \
      } else /* (y < (WordS##size)0) */ {                       \
        if (y < WordS##size##_quot (WordS##size##_max, x)) {    \
          doOverflow;                                           \
        }                                                       \
      }                                                         \
    }                                                           \
    doSuccess;                                                  \
  } while (0)
// #undef WordS_mulCheckBody
#define WordU_mulCheckBody(size, x, y, doOverflow, doSuccess)   \
  do {                                                          \
    if ((x == (WordU##size)0) || (y == (WordU##size)0)) {       \
    } else                                                      \
    if (x > WordU##size##_quot (Word##size##_max, y)) {         \
      doOverflow;                                               \
    }                                                           \
    doSuccess;                                                  \
  } while (0)
// #undef WordU_mulCheckBody
/* #define Word_mulCheckBody(small, large, x, y, doOverflow, doSuccess)    \ */
/*   do {                                                                  \ */
/*     Word##large tmp;                                                    \ */
/*     Word##small res;                                                    \  */
/*     tmp = ((Word##large)x) * ((Word##large)y);                          \ */
/*     res = (Word##small)tmp;                                             \ */
/*     if (tmp != res) {                                                   \ */
/*       doOverflow;                                                       \ */
/*     }                                                                   \ */
/*     doSuccess;                                                          \ */
/*   } while (0) */
/* #define WordS_mulCheckBody(small, large, x, y, doOverflow, doSuccess)   \ */
/* Word_mulCheckBody(S##small, S##large, x, y, doOverflow, doSuccess) */
/* #define WordU_mulCheckBody(small, large, x, y, doOverflow, doSuccess)   \ */
/* Word_mulCheckBody(U##small, U##large, x, y, doOverflow, doSuccess) */

#define WordS_negCheckBody(size, x, doOverflow, doSuccess)      \
  do {                                                          \
    if (x == WordS##size##_min) {                               \
      doOverflow;                                               \
    }                                                           \
    doSuccess;                                                  \
  } while (0)

#define WordS_subCheckBodyCX(size, c, x, doOverflow, doSuccess) \
  do {                                                          \
    if (c >= 0) {                                               \
      if (x < c - WordS##size##_max) {                          \
        doOverflow;                                             \
      }                                                         \
    } else if (x > c - WordS##size##_min) {                     \
      doOverflow;                                               \
    }                                                           \
    doSuccess;                                                  \
  } while (0)
#define WordS_subCheckBodyXC(size, x, c, doOverflow, doSuccess) \
  do {                                                          \
    if (c <= 0) {                                               \
      if (x > WordS##size##_max + c) {                          \
        doOverflow;                                             \
      }                                                         \
    } else if (x < WordS##size##_min + c) {                     \
      doOverflow;                                               \
    }                                                           \
    doSuccess;                                                  \
  } while (0)
#define WordS_subCheckBody(size, x, y, doOverflow, doSuccess)   \
WordS_subCheckBodyCX(size, x, y, doOverflow, doSuccess)


#define WordS_addCheckOverflows(size)                                   \
  MLTON_CODEGEN_STATIC_INLINE                                           \
  Bool WordS##size##_addCheckOverflows (WordS##size x, WordS##size y) { \
    WordS_addCheckBody(size, x, y, return TRUE, return FALSE);          \
  }

#define WordU_addCheckOverflows(size)                                   \
  MLTON_CODEGEN_STATIC_INLINE                                           \
  Bool WordU##size##_addCheckOverflows (WordU##size x, WordU##size y) { \
    WordU_addCheckBody(size, x, y, return TRUE, return FALSE);          \
  }

#define WordS_mulCheckOverflows(size)                                   \
  MLTON_CODEGEN_STATIC_INLINE                                           \
  Bool WordS##size##_mulCheckOverflows (WordS##size x, WordS##size y) { \
    WordS_mulCheckBody(size, x, y, return TRUE, return FALSE);          \
  }
#define WordU_mulCheckOverflows(size)                                   \
  MLTON_CODEGEN_STATIC_INLINE                                           \
  Bool WordU##size##_mulCheckOverflows (WordU##size x, WordU##size y) { \
    WordU_mulCheckBody(size, x, y, return TRUE, return FALSE);          \
  }

#define WordS_negCheckOverflows(size)                                   \
  MLTON_CODEGEN_STATIC_INLINE                                           \
  Bool WordS##size##_negCheckOverflows (WordS##size x) {                \
    WordS_negCheckBody(size, x, return TRUE, return FALSE);             \
  }

#define WordS_subCheckOverflows(size)                                   \
  MLTON_CODEGEN_STATIC_INLINE                                           \
  Bool WordS##size##_subCheckOverflows (WordS##size x, WordS##size y) { \
    WordS_subCheckBody(size, x, y, return TRUE, return FALSE);          \
  }

#define all(size)                               \
WordS_addCheckOverflows(size)                   \
WordU_addCheckOverflows(size)                   \
WordS_mulCheckOverflows(size)                   \
WordU_mulCheckOverflows(size)                   \
WordS_negCheckOverflows(size)                   \
WordS_subCheckOverflows(size)

all(8)
all(16)
all(32)
all(64)

#undef all
#undef WordS_subCheckOverflows
#undef WordS_negCheckOverflows
#undef WordU_mulCheckOverflows
#undef WordS_mulCheckOverflows
#undef WordU_addCheckOverflows
#undef WordS_addCheckOverflows
Commit	Line	Data
7f918cf1 CE	1
	2	#define WordS_addCheckBody(size, x, y, doOverflow, doSuccess) \
	3	do { \
	4	if (x >= 0) { \
	5	if (y > WordS##size##_max - x) { \
	6	doOverflow; \
	7	} \
	8	} else if (y < WordS##size##_min - x) { \
	9	doOverflow; \
	10	} \
	11	doSuccess; \
	12	} while (0)
	13	#define WordS_addCheckBodyCX(size, c, x, doOverflow, doSuccess) \
	14	WordS_addCheckBody(size, c, x, doOverflow, doSuccess)
	15
	16	#define WordU_addCheckBody(size, x, y, doOverflow, doSuccess) \
	17	do { \
	18	if (y > Word##size##_max - x) { \
	19	doOverflow; \
	20	} \
	21	doSuccess; \
	22	} while (0)
	23	#define WordU_addCheckBodyCX(size, c, x, doOverflow, doSuccess) \
	24	WordU_addCheckBody(size, c, x, doOverflow, doSuccess)
	25
	26	#define WordS_mulCheckBody(size, x, y, doOverflow, doSuccess) \
	27	do { \
	28	if ((x == (WordS##size)0) \|\| (y == (WordS##size)0)) { \
	29	} else \
	30	if (x > (WordS## size)0) { \
	31	if (y > (WordS##size)0) { \
	32	if (x > WordS##size##_quot (WordS##size##_max, y)) { \
	33	doOverflow; \
	34	} \
	35	} else /* (y < (WordS##size)0) */ { \
	36	if (y < WordS##size##_quot (WordS##size##_min, x)) { \
	37	doOverflow; \
	38	} \
	39	} \
	40	} else /* (x < (WordS##size)0) */ { \
	41	if (y > (WordS##size)0) { \
	42	if (x < WordS##size##_quot (WordS##size##_min, y)) { \
	43	doOverflow; \
	44	} \
	45	} else /* (y < (WordS##size)0) */ { \
	46	if (y < WordS##size##_quot (WordS##size##_max, x)) { \
	47	doOverflow; \
	48	} \
	49	} \
	50	} \
	51	doSuccess; \
	52	} while (0)
	53	// #undef WordS_mulCheckBody
	54	#define WordU_mulCheckBody(size, x, y, doOverflow, doSuccess) \
	55	do { \
	56	if ((x == (WordU##size)0) \|\| (y == (WordU##size)0)) { \
	57	} else \
	58	if (x > WordU##size##_quot (Word##size##_max, y)) { \
	59	doOverflow; \
	60	} \
	61	doSuccess; \
	62	} while (0)
	63	// #undef WordU_mulCheckBody
	64	/* #define Word_mulCheckBody(small, large, x, y, doOverflow, doSuccess) \ */
65	/* do { \ */
66	/* Word##large tmp; \ */
67	/* Word##small res; \ */
68	/* tmp = ((Word##large)x) * ((Word##large)y); \ */
69	/* res = (Word##small)tmp; \ */
70	/* if (tmp != res) { \ */
71	/* doOverflow; \ */
72	/* } \ */
73	/* doSuccess; \ */
74	/* } while (0) */
75	/* #define WordS_mulCheckBody(small, large, x, y, doOverflow, doSuccess) \ */
76	/* Word_mulCheckBody(S##small, S##large, x, y, doOverflow, doSuccess) */
77	/* #define WordU_mulCheckBody(small, large, x, y, doOverflow, doSuccess) \ */
78	/* Word_mulCheckBody(U##small, U##large, x, y, doOverflow, doSuccess) */
79
80	#define WordS_negCheckBody(size, x, doOverflow, doSuccess) \
81	do { \
82	if (x == WordS##size##_min) { \
83	doOverflow; \
84	} \
85	doSuccess; \
86	} while (0)
87
88	#define WordS_subCheckBodyCX(size, c, x, doOverflow, doSuccess) \
89	do { \
90	if (c >= 0) { \
91	if (x < c - WordS##size##_max) { \
92	doOverflow; \
93	} \
94	} else if (x > c - WordS##size##_min) { \
95	doOverflow; \
96	} \
97	doSuccess; \
98	} while (0)
99	#define WordS_subCheckBodyXC(size, x, c, doOverflow, doSuccess) \
100	do { \
101	if (c <= 0) { \
102	if (x > WordS##size##_max + c) { \
103	doOverflow; \
104	} \
105	} else if (x < WordS##size##_min + c) { \
106	doOverflow; \
107	} \
108	doSuccess; \
109	} while (0)
110	#define WordS_subCheckBody(size, x, y, doOverflow, doSuccess) \
111	WordS_subCheckBodyCX(size, x, y, doOverflow, doSuccess)
112
113
114	#define WordS_addCheckOverflows(size) \
115	MLTON_CODEGEN_STATIC_INLINE \
116	Bool WordS##size##_addCheckOverflows (WordS##size x, WordS##size y) { \
117	WordS_addCheckBody(size, x, y, return TRUE, return FALSE); \
118	}
119
120	#define WordU_addCheckOverflows(size) \
121	MLTON_CODEGEN_STATIC_INLINE \
122	Bool WordU##size##_addCheckOverflows (WordU##size x, WordU##size y) { \
123	WordU_addCheckBody(size, x, y, return TRUE, return FALSE); \
124	}
125
126	#define WordS_mulCheckOverflows(size) \
127	MLTON_CODEGEN_STATIC_INLINE \
128	Bool WordS##size##_mulCheckOverflows (WordS##size x, WordS##size y) { \
129	WordS_mulCheckBody(size, x, y, return TRUE, return FALSE); \
130	}
131	#define WordU_mulCheckOverflows(size) \
132	MLTON_CODEGEN_STATIC_INLINE \
133	Bool WordU##size##_mulCheckOverflows (WordU##size x, WordU##size y) { \
134	WordU_mulCheckBody(size, x, y, return TRUE, return FALSE); \
135	}
136
137	#define WordS_negCheckOverflows(size) \
138	MLTON_CODEGEN_STATIC_INLINE \
139	Bool WordS##size##_negCheckOverflows (WordS##size x) { \
140	WordS_negCheckBody(size, x, return TRUE, return FALSE); \
141	}
142
143	#define WordS_subCheckOverflows(size) \
144	MLTON_CODEGEN_STATIC_INLINE \
145	Bool WordS##size##_subCheckOverflows (WordS##size x, WordS##size y) { \
146	WordS_subCheckBody(size, x, y, return TRUE, return FALSE); \
147	}
148
149	#define all(size) \
150	WordS_addCheckOverflows(size) \
151	WordU_addCheckOverflows(size) \
152	WordS_mulCheckOverflows(size) \
153	WordU_mulCheckOverflows(size) \
154	WordS_negCheckOverflows(size) \
155	WordS_subCheckOverflows(size)
156
157	all(8)
158	all(16)
159	all(32)
160	all(64)
161
162	#undef all
163	#undef WordS_subCheckOverflows
164	#undef WordS_negCheckOverflows
165	#undef WordU_mulCheckOverflows
166	#undef WordS_mulCheckOverflows
167	#undef WordU_addCheckOverflows
168	#undef WordS_addCheckOverflows