LispObject


1   /*
2    * LispObject.java
3    *
4    * Copyright (C) 2002-2003 Peter Graves
5    * $Id: LispObject.java,v 1.98 2004/09/21 00:37:44 piso Exp $
6    *
7    * This program is free software; you can redistribute it and/or
8    * modify it under the terms of the GNU General Public License
9    * as published by the Free Software Foundation; either version 2
10   * of the License, or (at your option) any later version.
11   *
12   * This program is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   * GNU General Public License for more details.
16   *
17   * You should have received a copy of the GNU General Public License
18   * along with this program; if not, write to the Free Software
19   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
20   */
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         // Not reached.
217         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         // Not reached.
229         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         // Not reached.
241         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         // Not reached.
253         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         // Not reached.
275         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         // Not reached.
367         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         // Not reached.
394         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         // Not reached.
416         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     // Special operator
465     public LispObject execute(LispObject args, Environment env)
466         throws ConditionThrowable
467     {
468         return signal(new LispError());
469     }
470 
471     // Primitive
472     public LispObject execute(LispObject[] args) throws ConditionThrowable
473     {
474         return signal(new TypeError(this, Symbol.FUNCTION));
475     }
476 
477     // Primitive0
478     public LispObject execute() throws ConditionThrowable
479     {
480         return signal(new TypeError(this, Symbol.FUNCTION));
481     }
482 
483     // Primitive1
484     public LispObject execute(LispObject arg) throws ConditionThrowable
485     {
486         return signal(new TypeError(this, Symbol.FUNCTION));
487     }
488 
489     // Primitive2
490     public LispObject execute(LispObject first, LispObject second)
491         throws ConditionThrowable
492     {
493         return signal(new TypeError(this, Symbol.FUNCTION));
494     }
495 
496     // Primitive3
497     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     // Primitive4
505     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         // Not reached.
558         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         // Not reached.
570         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         // Not reached.
582         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         // Not reached.
594         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         // Not reached.
606         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         // Not reached.
618         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     // For EQUALP hash tables.
660     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         // Not reached.
674         return null;
675     }
676 
677     public char[] getStringChars() throws ConditionThrowable
678     {
679         signal(new TypeError(this, Symbol.STRING));
680         // Not reached.
681         return null;
682     }
683 
684     public String   getStringValue() throws ConditionThrowable
685     {
686         signal(new TypeError(this, Symbol.STRING));
687         // Not reached.
688         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     // Profiling.
703     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
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags