1 21 22 package org.armedbear.lisp; 23 24 public class LispObject extends Lisp 25 { 26 public int getFunctionalType() 27 { 28 return 0; 29 } 30 31 public LispObject typeOf() 32 { 33 return T; 34 } 35 36 public LispClass classOf() 37 { 38 return BuiltInClass.CLASS_T; 39 } 40 41 public LispObject getDescription() throws ConditionThrowable 42 { 43 StringBuffer sb = new StringBuffer ("An object of type "); 44 sb.append(typeOf().writeToString()); 45 return new SimpleString(sb); 46 } 47 48 public LispObject getParts() throws ConditionThrowable 49 { 50 return NIL; 51 } 52 53 public boolean getBooleanValue() 54 { 55 return true; 56 } 57 58 public LispObject typep(LispObject typeSpecifier) throws ConditionThrowable 59 { 60 if (typeSpecifier == T) 61 return T; 62 if (typeSpecifier == BuiltInClass.CLASS_T) 63 return T; 64 if (typeSpecifier == Symbol.ATOM) 65 return T; 66 return NIL; 67 } 68 69 public boolean constantp() 70 { 71 return true; 72 } 73 74 public LispObject CONSTANTP() 75 { 76 return constantp() ? T : NIL; 77 } 78 79 public LispObject ATOM() 80 { 81 return T; 82 } 83 84 public boolean atom() 85 { 86 return true; 87 } 88 89 public String getName() 90 { 91 return null; 92 } 93 94 public Object javaInstance() throws ConditionThrowable 95 { 96 return signal(new TypeError("The value " + writeToString() + 97 " is not of primitive type.")); 98 } 99 100 public Object javaInstance(Class c) throws ConditionThrowable 101 { 102 if (c == LispObject.class) 103 return this; 104 return signal(new TypeError("The value " + writeToString() + 105 " is not of primitive type.")); 106 } 107 108 public LispObject car() throws ConditionThrowable 109 { 110 return signal(new TypeError(this, Symbol.LIST)); 111 } 112 113 public void setCar(LispObject obj) throws ConditionThrowable 114 { 115 signal(new TypeError(this, Symbol.CONS)); 116 } 117 118 public LispObject RPLACA(LispObject obj) throws ConditionThrowable 119 { 120 return signal(new TypeError(this, Symbol.CONS)); 121 } 122 123 public LispObject _RPLACA(LispObject obj) throws ConditionThrowable 124 { 125 return signal(new TypeError(this, Symbol.CONS)); 126 } 127 128 public LispObject cdr() throws ConditionThrowable 129 { 130 return signal(new TypeError(this, Symbol.LIST)); 131 } 132 133 public void setCdr(LispObject obj) throws ConditionThrowable 134 { 135 signal(new TypeError(this, Symbol.CONS)); 136 } 137 138 public LispObject RPLACD(LispObject obj) throws ConditionThrowable 139 { 140 return signal(new TypeError(this, Symbol.CONS)); 141 } 142 143 public LispObject _RPLACD(LispObject obj) throws ConditionThrowable 144 { 145 return signal(new TypeError(this, Symbol.CONS)); 146 } 147 148 public LispObject cadr() throws ConditionThrowable 149 { 150 return signal(new TypeError(this, Symbol.LIST)); 151 } 152 153 public LispObject cddr() throws ConditionThrowable 154 { 155 return signal(new TypeError(this, Symbol.LIST)); 156 } 157 158 public LispObject push(LispObject obj) throws ConditionThrowable 159 { 160 return signal(new TypeError(this, Symbol.LIST)); 161 } 162 163 public LispObject EQ(LispObject obj) 164 { 165 return this == obj ? T : NIL; 166 } 167 168 public boolean eql(LispObject obj) 169 { 170 return this == obj; 171 } 172 173 public final LispObject EQL(LispObject obj) 174 { 175 return eql(obj) ? T : NIL; 176 } 177 178 public final LispObject EQUAL(LispObject obj) throws ConditionThrowable 179 { 180 return equal(obj) ? T : NIL; 181 } 182 183 public boolean equal(LispObject obj) throws ConditionThrowable 184 { 185 return this == obj; 186 } 187 188 public boolean equalp(LispObject obj) throws ConditionThrowable 189 { 190 return this == obj; 191 } 192 193 public LispObject ABS() throws ConditionThrowable 194 { 195 return signal(new TypeError(this, Symbol.NUMBER)); 196 } 197 198 public LispObject NUMERATOR() throws ConditionThrowable 199 { 200 return signal(new TypeError(this, Symbol.RATIONAL)); 201 } 202 203 public LispObject DENOMINATOR() throws ConditionThrowable 204 { 205 return signal(new TypeError(this, Symbol.RATIONAL)); 206 } 207 208 public LispObject EVENP() throws ConditionThrowable 209 { 210 return evenp() ? T : NIL; 211 } 212 213 public boolean evenp() throws ConditionThrowable 214 { 215 signal(new TypeError(this, Symbol.INTEGER)); 216 return false; 218 } 219 220 public LispObject ODDP() throws ConditionThrowable 221 { 222 return oddp() ? T : NIL; 223 } 224 225 public boolean oddp() throws ConditionThrowable 226 { 227 signal(new TypeError(this, Symbol.INTEGER)); 228 return false; 230 } 231 232 public LispObject PLUSP() throws ConditionThrowable 233 { 234 return plusp() ? T : NIL; 235 } 236 237 public boolean plusp() throws ConditionThrowable 238 { 239 signal(new TypeError(this, Symbol.REAL)); 240 return false; 242 } 243 244 public LispObject MINUSP() throws ConditionThrowable 245 { 246 return minusp() ? T : NIL; 247 } 248 249 public boolean minusp() throws ConditionThrowable 250 { 251 signal(new TypeError(this, Symbol.REAL)); 252 return false; 254 } 255 256 public LispObject NUMBERP() 257 { 258 return NIL; 259 } 260 261 public boolean numberp() 262 { 263 return false; 264 } 265 266 public LispObject ZEROP() throws ConditionThrowable 267 { 268 return zerop() ? T : NIL; 269 } 270 271 public boolean zerop() throws ConditionThrowable 272 { 273 signal(new TypeError(this, Symbol.NUMBER)); 274 return false; 276 } 277 278 public LispObject BIT_VECTOR_P() 279 { 280 return NIL; 281 } 282 283 public LispObject COMPLEXP() 284 { 285 return NIL; 286 } 287 288 public LispObject FLOATP() 289 { 290 return NIL; 291 } 292 293 public boolean floatp() 294 { 295 return false; 296 } 297 298 public LispObject INTEGERP() 299 { 300 return integerp() ? T : NIL; 301 } 302 303 public boolean integerp() 304 { 305 return false; 306 } 307 308 public LispObject RATIONALP() 309 { 310 return rationalp() ? T : NIL; 311 } 312 313 public boolean rationalp() 314 { 315 return false; 316 } 317 318 public LispObject REALP() 319 { 320 return realp() ? T : NIL; 321 } 322 323 public boolean realp() 324 { 325 return false; 326 } 327 328 public LispObject STRINGP() 329 { 330 return NIL; 331 } 332 333 public boolean stringp() 334 { 335 return false; 336 } 337 338 public LispObject SIMPLE_STRING_P() 339 { 340 return NIL; 341 } 342 343 public LispObject VECTORP() 344 { 345 return NIL; 346 } 347 348 public boolean vectorp() 349 { 350 return false; 351 } 352 353 public LispObject CHARACTERP() 354 { 355 return NIL; 356 } 357 358 public boolean characterp() 359 { 360 return false; 361 } 362 363 public int length() throws ConditionThrowable 364 { 365 signal(new TypeError(this, Symbol.SEQUENCE)); 366 return 0; 368 } 369 370 public final LispObject LENGTH() throws ConditionThrowable 371 { 372 return new Fixnum(length()); 373 } 374 375 public LispObject elt(int index) throws ConditionThrowable 376 { 377 return signal(new TypeError(this, Symbol.SEQUENCE)); 378 } 379 380 public LispObject nreverse() throws ConditionThrowable 381 { 382 return signal(new TypeError(this, Symbol.SEQUENCE)); 383 } 384 385 public LispObject AREF(LispObject index) throws ConditionThrowable 386 { 387 return signal(new TypeError(this, Symbol.ARRAY)); 388 } 389 390 public LispObject[] copyToArray() throws ConditionThrowable 391 { 392 signal(new TypeError(this, Symbol.LIST)); 393 return null; 395 } 396 397 public LispObject SYMBOLP() 398 { 399 return NIL; 400 } 401 402 public boolean listp() 403 { 404 return false; 405 } 406 407 public LispObject LISTP() 408 { 409 return NIL; 410 } 411 412 public boolean endp() throws ConditionThrowable 413 { 414 signal(new TypeError(this, Symbol.LIST)); 415 return false; 417 } 418 419 public LispObject ENDP() throws ConditionThrowable 420 { 421 return signal(new TypeError(this, Symbol.LIST)); 422 } 423 424 public LispObject NOT() 425 { 426 return NIL; 427 } 428 429 public boolean isSpecialVariable() 430 { 431 return false; 432 } 433 434 public LispObject getSymbolValue() throws ConditionThrowable 435 { 436 return signal(new TypeError(this, Symbol.SYMBOL)); 437 } 438 439 public LispObject getSymbolFunction() throws ConditionThrowable 440 { 441 return signal(new TypeError(this, Symbol.SYMBOL)); 442 } 443 444 public LispObject getSymbolFunctionOrDie() throws ConditionThrowable 445 { 446 return signal(new TypeError(this, Symbol.SYMBOL)); 447 } 448 449 public String writeToString() throws ConditionThrowable 450 { 451 return toString(); 452 } 453 454 public String unreadableString(String s) 455 { 456 StringBuffer sb = new StringBuffer ("#<"); 457 sb.append(s); 458 sb.append(" @ #x"); 459 sb.append(Integer.toHexString(System.identityHashCode(this))); 460 sb.append(">"); 461 return sb.toString(); 462 } 463 464 public LispObject execute(LispObject args, Environment env) 466 throws ConditionThrowable 467 { 468 return signal(new LispError()); 469 } 470 471 public LispObject execute(LispObject[] args) throws ConditionThrowable 473 { 474 return signal(new TypeError(this, Symbol.FUNCTION)); 475 } 476 477 public LispObject execute() throws ConditionThrowable 479 { 480 return signal(new TypeError(this, Symbol.FUNCTION)); 481 } 482 483 public LispObject execute(LispObject arg) throws ConditionThrowable 485 { 486 return signal(new TypeError(this, Symbol.FUNCTION)); 487 } 488 489 public LispObject execute(LispObject first, LispObject second) 491 throws ConditionThrowable 492 { 493 return signal(new TypeError(this, Symbol.FUNCTION)); 494 } 495 496 public LispObject execute(LispObject first, LispObject second, 498 LispObject third) 499 throws ConditionThrowable 500 { 501 return signal(new TypeError(this, Symbol.FUNCTION)); 502 } 503 504 public LispObject execute(LispObject first, LispObject second, 506 LispObject third, LispObject fourth) 507 throws ConditionThrowable 508 { 509 return signal(new TypeError(this, Symbol.FUNCTION)); 510 } 511 512 public LispObject execute(LispObject[] args, LispObject[] context) 513 throws ConditionThrowable 514 { 515 return signal(new TypeError(this, Symbol.FUNCTION)); 516 } 517 518 public LispObject execute(LispObject[] args, LispObject[][] context) 519 throws ConditionThrowable 520 { 521 return signal(new TypeError(this, Symbol.FUNCTION)); 522 } 523 524 public LispObject incr() throws ConditionThrowable 525 { 526 return signal(new TypeError(this, Symbol.NUMBER)); 527 } 528 529 public LispObject decr() throws ConditionThrowable 530 { 531 return signal(new TypeError(this, Symbol.NUMBER)); 532 } 533 534 public LispObject add(LispObject obj) throws ConditionThrowable 535 { 536 return signal(new TypeError(this, Symbol.NUMBER)); 537 } 538 539 public LispObject subtract(LispObject obj) throws ConditionThrowable 540 { 541 return signal(new TypeError(this, Symbol.NUMBER)); 542 } 543 544 public LispObject multiplyBy(LispObject obj) throws ConditionThrowable 545 { 546 return signal(new TypeError(this, Symbol.NUMBER)); 547 } 548 549 public LispObject divideBy(LispObject obj) throws ConditionThrowable 550 { 551 return signal(new TypeError(this, Symbol.NUMBER)); 552 } 553 554 public boolean isEqualTo(LispObject obj) throws ConditionThrowable 555 { 556 signal(new TypeError(this, Symbol.NUMBER)); 557 return false; 559 } 560 561 public LispObject IS_E(LispObject obj) throws ConditionThrowable 562 { 563 return isEqualTo(obj) ? T : NIL; 564 } 565 566 public boolean isNotEqualTo(LispObject obj) throws ConditionThrowable 567 { 568 signal(new TypeError(this, Symbol.NUMBER)); 569 return false; 571 } 572 573 public LispObject IS_NE(LispObject obj) throws ConditionThrowable 574 { 575 return isNotEqualTo(obj) ? T : NIL; 576 } 577 578 public boolean isLessThan(LispObject obj) throws ConditionThrowable 579 { 580 signal(new TypeError(this, Symbol.NUMBER)); 581 return false; 583 } 584 585 public LispObject IS_LT(LispObject obj) throws ConditionThrowable 586 { 587 return isLessThan(obj) ? T : NIL; 588 } 589 590 public boolean isGreaterThan(LispObject obj) throws ConditionThrowable 591 { 592 signal(new TypeError(this, Symbol.NUMBER)); 593 return false; 595 } 596 597 public LispObject IS_GT(LispObject obj) throws ConditionThrowable 598 { 599 return isGreaterThan(obj) ? T : NIL; 600 } 601 602 public boolean isLessThanOrEqualTo(LispObject obj) throws ConditionThrowable 603 { 604 signal(new TypeError(this, Symbol.NUMBER)); 605 return false; 607 } 608 609 public LispObject IS_LE(LispObject obj) throws ConditionThrowable 610 { 611 return isLessThanOrEqualTo(obj) ? T : NIL; 612 } 613 614 public boolean isGreaterThanOrEqualTo(LispObject obj) throws ConditionThrowable 615 { 616 signal(new TypeError(this, Symbol.NUMBER)); 617 return false; 619 } 620 621 public LispObject IS_GE(LispObject obj) throws ConditionThrowable 622 { 623 return isGreaterThanOrEqualTo(obj) ? T : NIL; 624 } 625 626 public LispObject truncate(LispObject obj) throws ConditionThrowable 627 { 628 return signal(new TypeError(this, Symbol.REAL)); 629 } 630 631 public LispObject MOD(LispObject divisor) throws ConditionThrowable 632 { 633 truncate(divisor); 634 final LispThread thread = LispThread.currentThread(); 635 LispObject remainder = thread._values[1]; 636 thread.clearValues(); 637 if (!remainder.zerop()) { 638 if (divisor.minusp()) { 639 if (plusp()) 640 return remainder.add(divisor); 641 } else { 642 if (minusp()) 643 return remainder.add(divisor); 644 } 645 } 646 return remainder; 647 } 648 649 public LispObject ash(LispObject obj) throws ConditionThrowable 650 { 651 return signal(new TypeError(obj, Symbol.INTEGER)); 652 } 653 654 public int sxhash() throws ConditionThrowable 655 { 656 return hashCode() & 0x7fffffff; 657 } 658 659 public int psxhash() throws ConditionThrowable 661 { 662 return sxhash(); 663 } 664 665 public LispObject STRING() throws ConditionThrowable 666 { 667 return signal(new TypeError(writeToString() + " cannot be coerced to a string.")); 668 } 669 670 public char[] chars() throws ConditionThrowable 671 { 672 signal(new TypeError(this, Symbol.STRING)); 673 return null; 675 } 676 677 public char[] getStringChars() throws ConditionThrowable 678 { 679 signal(new TypeError(this, Symbol.STRING)); 680 return null; 682 } 683 684 public String getStringValue() throws ConditionThrowable 685 { 686 signal(new TypeError(this, Symbol.STRING)); 687 return null; 689 } 690 691 public LispObject getSlotValue(int index) throws ConditionThrowable 692 { 693 return signal(new TypeError(this, Symbol.STRUCTURE_OBJECT)); 694 } 695 696 public LispObject setSlotValue(int index, LispObject value) 697 throws ConditionThrowable 698 { 699 return signal(new TypeError(this, Symbol.STRUCTURE_OBJECT)); 700 } 701 702 public int getCallCount() 704 { 705 return 0; 706 } 707 708 public void setCallCount(int n) 709 { 710 } 711 712 public void incrementCallCount() 713 { 714 } 715 } 716 | Popular Tags |