2 ent-indef.c -- Indefinite symbols for SXEmacs
3 Copyright (C) 2005, 2006 Sebastian Freundt
5 Author: Sebastian Freundt
7 This file is part of SXEmacs
9 SXEmacs is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
14 SXEmacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "sysproc.h" /* For qxe_getpid */
31 static inline int indef_eq(Lisp_Object, Lisp_Object);
32 static inline int indef_neq(Lisp_Object, Lisp_Object);
33 static int indef_lt(Lisp_Object, Lisp_Object);
34 static int indef_gt(Lisp_Object, Lisp_Object);
36 static int indef_le(Lisp_Object, Lisp_Object);
37 static int indef_ge(Lisp_Object, Lisp_Object);
39 static Lisp_Object indef_negate(Lisp_Object);
42 Lisp_Object Vnot_a_number;
43 Lisp_Object Vpinfinity;
44 Lisp_Object Vninfinity;
45 Lisp_Object Vcomplex_infinity;
49 indef_print (Lisp_Object obj, Lisp_Object printcharfun, int SXE_UNUSED(escapeflag))
51 Bufbyte *istr = indef_to_string(XINDEF_DATA(obj));
52 write_c_string((char*)istr, printcharfun);
54 istr = (Bufbyte *)NULL;
59 indef_equal (Lisp_Object obj1, Lisp_Object obj2, int SXE_UNUSED(depth))
61 return (XINDEF_DATA(obj1) == XINDEF_DATA(obj2));
65 indef_hash (Lisp_Object obj, int depth)
67 return (unsigned long)XINDEF_DATA(obj);
73 static const struct lrecord_description indef_description[] = {
74 { XD_INT, offsetof(Lisp_Indef, data) },
78 DEFINE_BASIC_LRECORD_IMPLEMENTATION("indef", indef,
79 NULL, indef_print, NULL,
80 indef_equal, indef_hash,
81 indef_description, Lisp_Indef);
84 Bufbyte *indef_to_string(indef i)
90 str = xnew_atomic_array(Bufbyte, 10);
91 memcpy((char*)str, "+infinity\000", 10);
94 str = xnew_atomic_array(Bufbyte, 10);
95 memcpy((char*)str, "-infinity\000", 10);
98 str = xnew_atomic_array(Bufbyte, 13);
99 memcpy((char*)str, "not-a-number\000", 13);
101 case COMPLEX_INFINITY:
102 str = xnew_atomic_array(Bufbyte, 17);
103 memcpy((char*)str, "complex-infinity\000", 17);
105 case END_OF_COMPARABLE_INFINITIES:
106 case END_OF_INFINITIES:
109 str = xnew_atomic_array(Bufbyte, 26);
110 memcpy((char*)str, "unknown indefinite symbol\000", 26);
118 ent_lift_indef(Lisp_Object number, ent_lift_args_t SXE_UNUSED(unused))
120 if (INFINITYP(number))
123 signal_error(Qdomain_error, list1(number));
129 ent_lift_INDEF_T_COMPARABLE(Lisp_Object number, ent_lift_args_t SXE_UNUSED(unused))
131 if (COMPARABLE_INDEF_P(number))
134 signal_error(Qdomain_error, list1(number));
139 static indef ent_optable_indef_sum[NUMBER_INDEFS][NUMBER_INDEFS];
140 static indef ent_optable_indef_diff[NUMBER_INDEFS][NUMBER_INDEFS];
141 static indef ent_optable_indef_prod[NUMBER_INDEFS][NUMBER_INDEFS];
142 static indef ent_optable_indef_div[NUMBER_INDEFS][NUMBER_INDEFS];
143 static indef ent_optable_indef_rem[NUMBER_INDEFS][NUMBER_INDEFS];
144 static indef ent_optable_indef_pow[NUMBER_INDEFS][NUMBER_INDEFS];
146 static void init_indef_table(void)
150 /* initialise NOT_A_NUMBER stuff */
151 for (i = 0; i < NUMBER_INDEFS; i++) {
152 ent_optable_indef_sum[NOT_A_NUMBER][i] = NOT_A_NUMBER;
153 ent_optable_indef_sum[i][NOT_A_NUMBER] = NOT_A_NUMBER;
154 ent_optable_indef_diff[NOT_A_NUMBER][i] = NOT_A_NUMBER;
155 ent_optable_indef_diff[i][NOT_A_NUMBER] = NOT_A_NUMBER;
156 ent_optable_indef_prod[NOT_A_NUMBER][i] = NOT_A_NUMBER;
157 ent_optable_indef_prod[i][NOT_A_NUMBER] = NOT_A_NUMBER;
158 ent_optable_indef_div[NOT_A_NUMBER][i] = NOT_A_NUMBER;
159 ent_optable_indef_div[i][NOT_A_NUMBER] = NOT_A_NUMBER;
160 ent_optable_indef_rem[NOT_A_NUMBER][i] = NOT_A_NUMBER;
161 ent_optable_indef_rem[i][NOT_A_NUMBER] = NOT_A_NUMBER;
162 ent_optable_indef_pow[NOT_A_NUMBER][i] = NOT_A_NUMBER;
163 ent_optable_indef_pow[i][NOT_A_NUMBER] = NOT_A_NUMBER;
167 ent_optable_indef_sum[POS_INFINITY][POS_INFINITY] = POS_INFINITY;
168 ent_optable_indef_sum[POS_INFINITY][NEG_INFINITY] = NOT_A_NUMBER;
169 ent_optable_indef_sum[POS_INFINITY][COMPLEX_INFINITY] = NOT_A_NUMBER;
171 ent_optable_indef_sum[NEG_INFINITY][POS_INFINITY] = NOT_A_NUMBER;
172 ent_optable_indef_sum[NEG_INFINITY][NEG_INFINITY] = NEG_INFINITY;
173 ent_optable_indef_sum[NEG_INFINITY][COMPLEX_INFINITY] = NOT_A_NUMBER;
175 ent_optable_indef_sum[COMPLEX_INFINITY][POS_INFINITY] = NOT_A_NUMBER;
176 ent_optable_indef_sum[COMPLEX_INFINITY][NEG_INFINITY] = NOT_A_NUMBER;
177 ent_optable_indef_sum[COMPLEX_INFINITY][COMPLEX_INFINITY] =
180 /* Subtraction table */
181 ent_optable_indef_diff[POS_INFINITY][POS_INFINITY] = NOT_A_NUMBER;
182 ent_optable_indef_diff[POS_INFINITY][NEG_INFINITY] = POS_INFINITY;
183 ent_optable_indef_diff[POS_INFINITY][COMPLEX_INFINITY] = NOT_A_NUMBER;
185 ent_optable_indef_diff[NEG_INFINITY][POS_INFINITY] = NEG_INFINITY;
186 ent_optable_indef_diff[NEG_INFINITY][NEG_INFINITY] = NOT_A_NUMBER;
187 ent_optable_indef_diff[NEG_INFINITY][COMPLEX_INFINITY] = NOT_A_NUMBER;
189 ent_optable_indef_diff[COMPLEX_INFINITY][POS_INFINITY] = NOT_A_NUMBER;
190 ent_optable_indef_diff[COMPLEX_INFINITY][NEG_INFINITY] = NOT_A_NUMBER;
191 ent_optable_indef_diff[COMPLEX_INFINITY][COMPLEX_INFINITY] =
194 /* Multiplication table */
195 ent_optable_indef_prod[POS_INFINITY][POS_INFINITY] = POS_INFINITY;
196 ent_optable_indef_prod[POS_INFINITY][NEG_INFINITY] = NEG_INFINITY;
197 ent_optable_indef_prod[POS_INFINITY][COMPLEX_INFINITY] =
200 ent_optable_indef_prod[NEG_INFINITY][POS_INFINITY] = NEG_INFINITY;
201 ent_optable_indef_prod[NEG_INFINITY][NEG_INFINITY] = POS_INFINITY;
202 ent_optable_indef_prod[NEG_INFINITY][COMPLEX_INFINITY] =
205 ent_optable_indef_prod[COMPLEX_INFINITY][POS_INFINITY] =
207 ent_optable_indef_prod[COMPLEX_INFINITY][NEG_INFINITY] =
209 ent_optable_indef_prod[COMPLEX_INFINITY][COMPLEX_INFINITY] =
213 ent_optable_indef_div[POS_INFINITY][POS_INFINITY] = NOT_A_NUMBER;
214 ent_optable_indef_div[POS_INFINITY][NEG_INFINITY] = NOT_A_NUMBER;
215 ent_optable_indef_div[POS_INFINITY][COMPLEX_INFINITY] =
218 ent_optable_indef_div[NEG_INFINITY][POS_INFINITY] = NOT_A_NUMBER;
219 ent_optable_indef_div[NEG_INFINITY][NEG_INFINITY] = NOT_A_NUMBER;
220 ent_optable_indef_div[NEG_INFINITY][COMPLEX_INFINITY] =
223 ent_optable_indef_div[COMPLEX_INFINITY][POS_INFINITY] =
225 ent_optable_indef_div[COMPLEX_INFINITY][NEG_INFINITY] =
227 ent_optable_indef_div[COMPLEX_INFINITY][COMPLEX_INFINITY] =
231 ent_optable_indef_rem[POS_INFINITY][POS_INFINITY] = POS_INFINITY;
232 ent_optable_indef_rem[POS_INFINITY][NEG_INFINITY] = NEG_INFINITY;
233 ent_optable_indef_rem[POS_INFINITY][COMPLEX_INFINITY] =
236 ent_optable_indef_rem[NEG_INFINITY][POS_INFINITY] = NEG_INFINITY;
237 ent_optable_indef_rem[NEG_INFINITY][NEG_INFINITY] = POS_INFINITY;
238 ent_optable_indef_rem[NEG_INFINITY][COMPLEX_INFINITY] =
241 ent_optable_indef_rem[COMPLEX_INFINITY][POS_INFINITY] =
243 ent_optable_indef_rem[COMPLEX_INFINITY][NEG_INFINITY] =
245 ent_optable_indef_rem[COMPLEX_INFINITY][COMPLEX_INFINITY] =
248 /* exponentiation table */
249 ent_optable_indef_pow[POS_INFINITY][POS_INFINITY] = NOT_A_NUMBER;
250 ent_optable_indef_pow[POS_INFINITY][NEG_INFINITY] = NOT_A_NUMBER;
251 ent_optable_indef_pow[POS_INFINITY][COMPLEX_INFINITY] =
254 ent_optable_indef_pow[NEG_INFINITY][POS_INFINITY] = NOT_A_NUMBER;
255 ent_optable_indef_pow[NEG_INFINITY][NEG_INFINITY] = NOT_A_NUMBER;
256 ent_optable_indef_pow[NEG_INFINITY][COMPLEX_INFINITY] =
259 ent_optable_indef_pow[COMPLEX_INFINITY][POS_INFINITY] =
261 ent_optable_indef_pow[COMPLEX_INFINITY][NEG_INFINITY] =
263 ent_optable_indef_pow[COMPLEX_INFINITY][COMPLEX_INFINITY] =
267 #define INDEF_AUTOOPERATE(op, l1, l2) \
268 make_indef(ent_optable_indef_##op[XINDEF_DATA(l1)][XINDEF_DATA(l2)])
270 static Lisp_Object indef_negate(Lisp_Object ind)
272 if (XINDEF_DATA(ind) == POS_INFINITY) {
273 return make_indef(NEG_INFINITY);
274 } else if (XINDEF_DATA(ind) == NEG_INFINITY) {
275 return make_indef(POS_INFINITY);
276 } else if (XINDEF_DATA(ind) == COMPLEX_INFINITY) {
279 return make_indef(NOT_A_NUMBER);
284 indef_sum(Lisp_Object l, Lisp_Object r)
286 if (INDEFP(l) && INDEFP(r))
287 return INDEF_AUTOOPERATE(sum, l, r);
289 if (INDEFP(l) && NUMBERP(r))
291 else if (NUMBERP(l) && INDEFP(r))
294 return make_indef(NOT_A_NUMBER);
297 indef_diff(Lisp_Object l, Lisp_Object r)
299 if (INDEFP(l) && INDEFP(r))
300 return INDEF_AUTOOPERATE(diff, l, r);
302 if (INDEFP(l) && NUMBERP(r))
304 else if (NUMBERP(l) && INDEFP(r))
305 return indef_negate(r);
307 return make_indef(NOT_A_NUMBER);
310 indef_prod(Lisp_Object l, Lisp_Object r)
312 if (INDEFP(l) && INDEFP(r))
313 return INDEF_AUTOOPERATE(prod, l, r);
315 if (INDEFP(l) && COMPARABLEP(r)) {
316 if (!NILP(Fzerop(r)))
317 return make_indef(NOT_A_NUMBER);
318 else if (!NILP(Fnonnegativep(r)))
321 return indef_negate(l);
322 } else if (COMPARABLEP(l) && INDEFP(r)) {
323 if (!NILP(Fzerop(l)))
324 return make_indef(NOT_A_NUMBER);
325 else if (!NILP(Fnonnegativep(l)))
328 return indef_negate(r);
329 } else if (INFINITYP(l) || INFINITYP(r)) {
330 return make_indef(COMPLEX_INFINITY);
332 return make_indef(NOT_A_NUMBER);
336 indef_div(Lisp_Object l, Lisp_Object r)
338 if (INDEFP(l) && INDEFP(r))
339 return INDEF_AUTOOPERATE(div, l, r);
341 if (INDEFP(l) && COMPARABLEP(r)) {
342 if (!NILP(Fzerop(r)))
343 return make_indef(NOT_A_NUMBER);
344 else if (!NILP(Fnonnegativep(r)))
347 return indef_negate(l);
348 } else if (COMPARABLEP(l) && INDEFP(r)) {
349 if (!COMPARABLE_INDEF_P(r))
353 } else if (INFINITYP(l) || INFINITYP(r)) {
354 return make_indef(COMPLEX_INFINITY);
356 return make_indef(NOT_A_NUMBER);
360 indef_inv(Lisp_Object l)
362 switch (XINDEF_DATA(l)) {
367 case COMPLEX_INFINITY:
371 case END_OF_COMPARABLE_INFINITIES:
372 case END_OF_INFINITIES:
375 abort(); /* punishment enough? */
382 indef_rem(Lisp_Object l, Lisp_Object r)
384 if (INDEFP(l) && INDEFP(r))
385 return INDEF_AUTOOPERATE(rem, l, r);
387 if (INDEFP(l) && COMPARABLEP(r)) {
388 return make_indef(NOT_A_NUMBER);
389 } else if (COMPARABLEP(l) && INFINITYP(r)) {
391 } else if (COMPARABLEP(l) && NOT_A_NUMBER_P(r)) {
393 } else if (INFINITE_POINT_P(r)) {
396 return make_indef(NOT_A_NUMBER);
400 indef_pow(Lisp_Object l, Lisp_Object r)
402 if (INDEFP(l) && INDEFP(r))
403 return INDEF_AUTOOPERATE(pow, l, r);
405 if (INDEFP(l) && !NILP(Fzerop(r))) {
406 return make_indef(NOT_A_NUMBER);
407 } else if (COMPARABLE_INDEF_P(l) && COMPARABLEP(r)) {
408 if (!NILP(Fzerop(r)))
409 return make_indef(NOT_A_NUMBER);
410 else if (NILP(Fnonnegativep(r)))
412 else if (XINDEF_DATA(l) == NEG_INFINITY &&
414 return make_indef(POS_INFINITY);
417 } else if (INDEFP(l) && COMPARABLEP(r)) {
419 } else if (INFINITE_POINT_P(l)) {
420 return make_indef(COMPLEX_INFINITY);
421 } else if (INDEFP(l)) {
422 return make_indef(NOT_A_NUMBER);
423 } else if (COMPARABLEP(l) && COMPARABLE_INDEF_P(r)) {
424 Lisp_Object comp[3] = {make_int(-1), l, make_int(1)};
425 if (ent_unrel(ASE_UNARY_REL_ONEP, l)) /* l == 1 */
427 else if (ent_binrel_transitive_many(
428 ASE_BINARY_REL_LESSP, 3, comp))
431 else if (ent_binrel(ASE_BINARY_REL_LESSP, Qone, l)) {
433 if (XINDEF_DATA(r) == POS_INFINITY)
438 return make_indef(NOT_A_NUMBER);
439 } else if (COMPARABLEP(l) && INFINITYP(r)) {
440 return make_indef(COMPLEX_INFINITY);
442 return make_indef(NOT_A_NUMBER);
446 indef_eq(Lisp_Object l1, Lisp_Object l2)
448 if (INDEFP(l1) && INDEFP(l2) &&
449 INFINITYP(l1) && INFINITYP(l2))
450 return (XINDEF_DATA(l1) == XINDEF_DATA(l2));
451 else if (!COMPARABLEP(l1) || !COMPARABLEP(l2)) {
452 Fsignal(Qrelation_error, list2(l1, l2));
459 indef_neq(Lisp_Object l1, Lisp_Object l2)
461 return !(indef_eq(l1, l2));
465 indef_lt(Lisp_Object l1, Lisp_Object l2)
467 if (!COMPARABLEP(l1) || !COMPARABLEP(l2)) {
468 Fsignal(Qrelation_error, list2(l1, l2));
472 if (INDEFP(l1) && INDEFP(l2)) {
473 /* only +infinity is not less than -infinity */
474 if ((XINDEF_DATA(l1) == POS_INFINITY) &&
475 (XINDEF_DATA(l2) == NEG_INFINITY))
479 } else if (!INDEFP(l1)) {
480 if (XINDEF_DATA(l2) == NEG_INFINITY)
484 } else if (!INDEFP(l2)) {
485 if (XINDEF_DATA(l1) == POS_INFINITY)
490 return wrong_type_argument(Qindefinitep, l1);
495 indef_le(Lisp_Object l1, Lisp_Object l2)
497 if (!COMPARABLEP(l1) || !COMPARABLEP(l2)) {
498 Fsignal(Qrelation_error, list2(l1, l2));
502 if (INDEFP(l1) && INDEFP(l2)) {
503 /* only +infinity is not leq -infinity */
504 if ((XINDEF_DATA(l1) == POS_INFINITY) &&
505 (XINDEF_DATA(l2) == NEG_INFINITY))
509 } else if (!INDEFP(l1)) {
510 if (XINDEF_DATA(l2) == NEG_INFINITY)
514 } else if (!INDEFP(l2)) {
515 if (XINDEF_DATA(l1) == POS_INFINITY)
520 return wrong_type_argument(Qindefinitep, l1);
525 indef_gt(Lisp_Object l1, Lisp_Object l2)
527 if (!COMPARABLEP(l1) || !COMPARABLEP(l2)) {
528 Fsignal(Qrelation_error, list2(l1, l2));
532 if (INDEFP(l1) && INDEFP(l2)) {
533 /* only -infinity is not greater than +infinity */
534 if ((XINDEF_DATA(l1) == NEG_INFINITY) &&
535 (XINDEF_DATA(l2) == POS_INFINITY))
539 } else if (!INDEFP(l1)) {
540 if (XINDEF_DATA(l2) == POS_INFINITY)
544 } else if (!INDEFP(l2)) {
545 if (XINDEF_DATA(l1) == NEG_INFINITY)
550 return wrong_type_argument(Qindefinitep, l1);
555 indef_ge(Lisp_Object l1, Lisp_Object l2)
557 if (!COMPARABLEP(l1) || !COMPARABLEP(l2)) {
558 Fsignal(Qrelation_error, list2(l1, l2));
562 if (INDEFP(l1) && INDEFP(l2)) {
563 /* only -infinity is not geq +infinity */
564 if ((XINDEF_DATA(l1) == NEG_INFINITY) &&
565 (XINDEF_DATA(l2) == POS_INFINITY))
569 } else if (!INDEFP(l1)) {
570 if (XINDEF_DATA(l2) == POS_INFINITY)
574 } else if (!INDEFP(l2)) {
575 if (XINDEF_DATA(l1) == NEG_INFINITY)
580 return wrong_type_argument(Qindefinitep, l1);
585 ent_indef_neutralp(Lisp_Object unused)
592 ent_indef_nullary_optable_init(void)
594 ent_nullop_register(ASE_NULLARY_OP_ZERO, INDEF_T, Qzero);
595 ent_nullop_register(ASE_NULLARY_OP_ONE, INDEF_T, Qone);
599 ent_indef_unary_optable_init(void)
601 ent_unop_register(ASE_UNARY_OP_NEG, INDEF_T, indef_negate);
602 ent_unop_register(ASE_UNARY_OP_INV, INDEF_T, indef_inv);
606 ent_indef_binary_optable_init(void)
610 for (i = 0; i < ASE_OPTABLE_SIZE; i++) {
611 ent_binop_register(ASE_BINARY_OP_SUM, i, INDEF_T, indef_sum);
612 ent_binop_register(ASE_BINARY_OP_SUM, INDEF_T, i, indef_sum);
613 ent_binop_register(ASE_BINARY_OP_DIFF, i, INDEF_T, indef_diff);
614 ent_binop_register(ASE_BINARY_OP_DIFF, INDEF_T, i, indef_diff);
615 ent_binop_register(ASE_BINARY_OP_PROD, i, INDEF_T, indef_prod);
616 ent_binop_register(ASE_BINARY_OP_PROD, INDEF_T, i, indef_prod);
617 ent_binop_register(ASE_BINARY_OP_DIV, i, INDEF_T, indef_div);
618 ent_binop_register(ASE_BINARY_OP_DIV, INDEF_T, i, indef_div);
619 ent_binop_register(ASE_BINARY_OP_QUO, i, INDEF_T, indef_div);
620 ent_binop_register(ASE_BINARY_OP_QUO, INDEF_T, i, indef_div);
621 ent_binop_register(ASE_BINARY_OP_REM, i, INDEF_T, indef_rem);
622 ent_binop_register(ASE_BINARY_OP_REM, INDEF_T, i, indef_rem);
623 ent_binop_register(ASE_BINARY_OP_POW, i, INDEF_T, indef_pow);
624 ent_binop_register(ASE_BINARY_OP_POW, INDEF_T, i, indef_pow);
629 ent_indef_unary_reltable_init(void)
631 ent_unrel_register(ASE_UNARY_REL_ZEROP, INDEF_T, ent_indef_neutralp);
632 ent_unrel_register(ASE_UNARY_REL_ONEP, INDEF_T, ent_indef_neutralp);
636 ent_indef_binary_reltable_init(void)
638 ase_object_type_t idx = INDEF_T, i;
640 for (i = 0; i < ASE_OPTABLE_SIZE; i++) {
641 ent_binrel_register(ASE_BINARY_REL_LESSP, i, idx, indef_lt);
642 ent_binrel_register(ASE_BINARY_REL_LESSP, idx, i, indef_lt);
643 ent_binrel_register(ASE_BINARY_REL_GREATERP, i, idx, indef_gt);
644 ent_binrel_register(ASE_BINARY_REL_GREATERP, idx, i, indef_gt);
645 ent_binrel_register(ASE_BINARY_REL_EQUALP, i, idx, indef_eq);
646 ent_binrel_register(ASE_BINARY_REL_EQUALP, idx, i, indef_eq);
647 ent_binrel_register(ASE_BINARY_REL_NEQP, i, idx, indef_neq);
648 ent_binrel_register(ASE_BINARY_REL_NEQP, idx, i, indef_neq);
653 ent_indef_lifttable_init(void)
656 for (i = 0; i < ASE_OPTABLE_SIZE; i++) {
657 ent_lift_register(INDEF_T, i, ent_lift_indef);
662 void init_optables_INDEF_T(void)
664 ent_indef_nullary_optable_init();
665 ent_indef_unary_optable_init();
666 ent_indef_binary_optable_init();
667 ent_indef_unary_reltable_init();
668 ent_indef_binary_reltable_init();
669 ent_indef_lifttable_init();
672 void init_ent_indef(void)
677 void syms_of_ent_indef(void)
679 INIT_LRECORD_IMPLEMENTATION(indef);
682 void vars_of_ent_indef(void)
684 /* Now define +infinity and -infinity, complex-infinity and not-a-number */
685 Vnot_a_number = make_indef_internal((indef)NOT_A_NUMBER);
686 Vninfinity = make_indef_internal((indef)NEG_INFINITY);
687 Vpinfinity = make_indef_internal((indef)POS_INFINITY);
688 Vcomplex_infinity = make_indef_internal((indef)COMPLEX_INFINITY);
690 DEFVAR_CONST_LISP("not-a-number", &Vnot_a_number /*
693 DEFVAR_CONST_LISP("+infinity", &Vpinfinity /*
696 DEFVAR_CONST_LISP("-infinity", &Vninfinity /*
699 DEFVAR_CONST_LISP("complex-infinity", &Vcomplex_infinity /*
700 The infinitely distant point in the complex plane.
703 staticpro(&Vnot_a_number);
704 staticpro(&Vninfinity);
705 staticpro(&Vpinfinity);
706 staticpro(&Vcomplex_infinity);
708 Fprovide(intern("indefinite"));
709 Fprovide(intern("infinity"));
712 /* ent-indef.c ends here */