source: trunk/abcl/src/org/armedbear/lisp/GrayStream.java

Last change on this file was 15779, checked in by Mark Evenson, 3 months ago

Add support for gray:stream-file-string-length
File size: 11.6 KB
Line 
1package org.armedbear.lisp;
2
3import java.util.HashMap;
4import static org.armedbear.lisp.Lisp.*;
5
6/**
7   The Java proxy for Gray streams which wraps the reference of the
8   CLOS object corresponding to the stream, and trampolines calls to
9   overloaded Stream.java methods through the generic method
10   machinery.
11*/
12public class GrayStream 
13  extends Stream
14{
15  LispObject clos = null;
16 
17  // objects are created via memoization via findOrCreate(LispObject)
18  private GrayStream(LispObject clos) {
19    super(Symbol.CLOS_STREAM);
20    this.clos = clos;
21  }
22
23  // TODO: can we make this a weak hash?  But the value contains a
24  // reference to the key, so use a weak reference to clos?
25  static HashMap<LispObject, GrayStream> objects
26    = new HashMap<LispObject, GrayStream>();
27 
28  synchronized // ???
29    static 
30  public GrayStream findOrCreate(LispObject o) {
31    GrayStream wrappedStream
32      = objects.get(o);
33    if (wrappedStream == null) {
34      wrappedStream = new GrayStream(o);
35      objects.put(o, wrappedStream);
36    }
37    return wrappedStream;
38  }
39
40  //
41  // do what we can for Java code that wants to determine our valence(s)
42  //
43  public static final Symbol INPUT_STREAM_P
44    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/INPUT-STREAM-P");
45  public boolean isInputStream() {
46    Function f = checkFunction(INPUT_STREAM_P.getSymbolFunction());
47    return f.execute(clos).getBooleanValue();
48  }
49
50  public static final Symbol OUTPUT_STREAM_P
51    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/OUTPUT-STREAM-P");
52  public boolean isOutputStream() {
53    Function f = checkFunction(OUTPUT_STREAM_P.getSymbolFunction());
54    return f.execute(clos).getBooleanValue();
55  }
56
57  public static final Symbol INTERACTIVE_STREAM_P
58    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/INTERACTIVE-STREAM-P");
59  public boolean isInteractive() {
60    Function f = checkFunction(INTERACTIVE_STREAM_P.getSymbolFunction());
61    return f.execute(clos).getBooleanValue();
62  }
63
64  public static final Symbol OPEN_STREAM_P
65    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/OPEN-STREAM-P");
66  public boolean isOpen() {
67    Function f = checkFunction(OPEN_STREAM_P.getSymbolFunction());
68    return f.execute(clos).getBooleanValue();
69  }
70
71  public boolean isCharacterStream() {
72    Function subtypep = checkFunction(Symbol.SUBTYPEP.getSymbolFunction());
73    return subtypep.execute(getElementType(), Symbol.CHARACTER).getBooleanValue();
74  }
75
76  public boolean isBinaryStream() {
77    return !isCharacterStream();
78  }
79
80  public boolean isCharacterInputStream() {
81    return isCharacterStream() && isInputStream();
82  }
83
84  public boolean isCharacterOutputStream() {
85    return isCharacterStream() && isOutputStream();
86  }
87
88  public boolean isBinaryInputStream() {
89    return isBinaryStream() && isInputStream();
90  }
91
92  public boolean isBinaryOutputStream() {
93    return isBinaryStream() && isOutputStream();
94  }
95
96  // TODO
97  //   return Lisp type as Stream or as clos object?
98  //
99  /*
100  public LispObject typeOf() {}
101  public LispObject classOf() {}
102  public LispObject typep(LispObject typeSpecifier) {}
103  */
104
105  //
106  // methods forwarded to the possible Gray stream implementation
107  //
108
109  public static final Symbol ELEMENT_TYPE
110    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/ELEMENT-TYPE");
111  @Override
112  public LispObject getElementType() {
113    Function f = checkFunction(ELEMENT_TYPE.getSymbolFunction());
114    return f.execute(clos);
115  }
116 
117  public static final Symbol EXTERNAL_FORMAT
118    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/EXTERNAL-FORMAT");
119  @Override
120  public LispObject getExternalFormat() {
121    Function f = checkFunction(EXTERNAL_FORMAT.getSymbolFunction());
122    return f.execute(clos);
123  }
124
125  public static final Symbol SET_EXTERNAL_FORMAT
126    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/SET-EXTERNAL-FORMAT");
127  @Override
128  public void setExternalFormat(LispObject format) {
129    Function f = checkFunction(SET_EXTERNAL_FORMAT.getSymbolFunction());
130    f.execute(clos, format);
131  }
132
133  public static final Symbol FORCE_OUTPUT
134    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/FORCE-OUTPUT");
135  public void _forceOutput() {
136    Function f = checkFunction(FORCE_OUTPUT.getSymbolFunction());
137    f.execute(clos);
138  }
139
140  public static final Symbol WRITE_STRING
141    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/WRITE-STRING");
142  public void _writeString(String string) {
143    Function f = checkFunction(WRITE_STRING.getSymbolFunction());
144    SimpleString s = new SimpleString(string);
145    f.execute(clos, s);
146  }
147
148  public static final Symbol WRITE_CHAR
149    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/WRITE-CHAR");
150  public void _writeChar(char c) {
151    Function f = checkFunction(WRITE_CHAR.getSymbolFunction());
152    f.execute(clos, LispCharacter.getInstance(c));
153  }
154
155
156  public static final Symbol WRITE_CHARS
157    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/WRITE-CHARS");
158  public void _writeChars(char[] chars, int start, int end) {
159    Function f = checkFunction(WRITE_CHARS.getSymbolFunction());
160    SimpleString string = new SimpleString(chars); // XXX under an encoding?
161    f.execute(clos, string,
162              LispInteger.getInstance(start),
163              LispInteger.getInstance(end));
164  }
165
166  public static final Symbol FRESH_LINE
167    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/FRESH-LINE");
168  public LispObject freshLine() {
169    Function f = checkFunction(FRESH_LINE.getSymbolFunction());
170    return f.execute(clos);
171  }
172
173  public static final Symbol READ_CHAR
174    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/READ-CHAR");
175  public int _readChar() {
176    Function f = checkFunction(READ_CHAR.getSymbolFunction());
177    LispObject result = f.execute(clos);
178    if (result instanceof LispCharacter) {
179      return checkCharacter(result).getValue();
180    }
181    return -1;
182  }
183
184  public static final Symbol UNREAD_CHAR
185    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/UNREAD-CHAR");
186  public void _unreadChar(int n) {
187    Function f = checkFunction(UNREAD_CHAR.getSymbolFunction());
188    f.execute(clos, LispCharacter.getInstance((char)n));
189  }
190
191  public static final Symbol STREAM_LISTEN
192    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/LISTEN");
193  protected boolean _charReady()
194  {
195    Function f = checkFunction(STREAM_LISTEN.getSymbolFunction());
196    if (STREAM_LISTEN.execute(clos).equals(T)) {
197      return true;
198    }
199    return false; 
200  }
201
202  protected boolean _byteReady()
203  {
204    simple_error("unimplemented _byteReady()");
205    return false; // unreached
206  }
207
208  public static final Symbol READ_BYTE
209    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/READ-BYTE");
210  public int _readByte() {
211    Function f = checkFunction(READ_BYTE.getSymbolFunction());
212    LispObject result = f.execute(clos);
213    return result.intValue();
214  }
215
216  public static final Symbol WRITE_BYTE
217    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/WRITE-BYTE");
218  public void _writeByte(int n) {
219    Function f = checkFunction(WRITE_BYTE.getSymbolFunction());
220    f.execute(clos, LispInteger.getInstance(n));
221  }
222
223  public static final Symbol CLEAR_INPUT
224    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/CLEAR-INPUT");
225  public void _clearInput() {
226    Function f = checkFunction(CLEAR_INPUT.getSymbolFunction());
227    f.execute(clos);
228  }
229
230  public static final Symbol FINISH_OUTPUT
231    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/FINISH-OUTPUT");
232  public void _finishOutput() {
233    Function f = checkFunction(FINISH_OUTPUT.getSymbolFunction());
234    f.execute(clos);
235  }
236
237  public static final Symbol FILE_POSITION
238    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/FILE-POSITION");
239  public long _getFilePosition() {
240    Function f = checkFunction(FILE_POSITION.getSymbolFunction());
241    LispObject result = f.execute(clos);
242    return result.longValue();
243  }
244
245  public static final Symbol SET_FILE_POSITION
246    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/SET-FILE-POSITION");
247  public boolean _setFilePosition(LispObject arg) {
248    Function f = checkFunction(SET_FILE_POSITION.getSymbolFunction());
249    return f.execute(clos, arg).getBooleanValue();
250  }
251
252  public static final Symbol FILE_LENGTH
253    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/FILE-LENGTH");
254  @Override
255  public LispObject fileLength() {
256    Function f = checkFunction(FILE_LENGTH.getSymbolFunction());
257    return f.execute(clos);
258  }
259
260  public static final Symbol FILE_STRING_LENGTH
261    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/FILE-STRING-LENGTH");
262  @Override
263  public LispObject fileStringLength(LispObject arg) {
264    Function f = checkFunction(FILE_STRING_LENGTH.getSymbolFunction());
265    return f.execute(clos, arg);
266  }
267
268  public static final Symbol PATHNAME
269    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/PATHNAME");
270  @Override
271  public Pathname getPathname() {
272    Function f = checkFunction(PATHNAME.getSymbolFunction());
273    return (Pathname)f.execute(clos);
274  }
275
276  public static final Symbol LINE_COLUMN
277    = PACKAGE_GRAY_STREAMS_JAVA.addExternalSymbol("JAVA/LINE-COLUMN");
278  public int getCharPos() {
279    Function f = checkFunction(LINE_COLUMN.getSymbolFunction());
280    LispObject result = f.execute(clos);
281    return result.intValue();
282  }
283
284  //
285  // unimplemented interfaces of parent class
286  //
287  // we stub these to return Lisp-side errors
288  public void setInteractive(boolean b) {
289    simple_error("unimplemented setInteractive(boolean)");
290  }
291
292  public String getEncoding() {
293    simple_error("unimplemented getEncoding()");
294    return null;  // unreached
295  }
296
297  public void setOpen(boolean b) {
298    simple_error("unimplemented setOpen()");;
299  }
300
301  public int getOffset() {
302    simple_error("unimplemented getOffset()");
303    return 0; // unreached
304  }
305
306  public final int getLineNumber() {
307    simple_error("unimplemented getLineNumber()");
308    return 0;  // unreached
309  }
310
311  // TODO figure out why we can't add these to autoloads.lisp
312  static {
313    Autoload.autoloadFile(GrayStream.INPUT_STREAM_P, "gray-streams-java");
314    Autoload.autoloadFile(GrayStream.OUTPUT_STREAM_P, "gray-streams-java");
315    Autoload.autoloadFile(GrayStream.INTERACTIVE_STREAM_P, "gray-streams-java");
316    Autoload.autoloadFile(GrayStream.OPEN_STREAM_P, "gray-streams-java");
317    Autoload.autoloadFile(GrayStream.ELEMENT_TYPE, "gray-streams-java");
318    Autoload.autoloadFile(GrayStream.EXTERNAL_FORMAT, "gray-streams-java");
319    Autoload.autoloadFile(GrayStream.SET_EXTERNAL_FORMAT, "gray-streams-java");
320    Autoload.autoloadFile(GrayStream.FORCE_OUTPUT, "gray-streams-java");
321    Autoload.autoloadFile(GrayStream.WRITE_STRING, "gray-streams-java");
322    Autoload.autoloadFile(GrayStream.WRITE_CHAR, "gray-streams-java");
323    Autoload.autoloadFile(GrayStream.WRITE_CHARS, "gray-streams-java");
324    Autoload.autoloadFile(GrayStream.FRESH_LINE, "gray-streams-java");
325    Autoload.autoloadFile(GrayStream.READ_CHAR, "gray-streams-java");
326    Autoload.autoloadFile(GrayStream.UNREAD_CHAR, "gray-streams-java");
327    Autoload.autoloadFile(GrayStream.STREAM_LISTEN, "gray-streams-java");
328    Autoload.autoloadFile(GrayStream.READ_BYTE, "gray-streams-java");
329    Autoload.autoloadFile(GrayStream.WRITE_BYTE, "gray-streams-java");
330    Autoload.autoloadFile(GrayStream.CLEAR_INPUT, "gray-streams-java");
331    Autoload.autoloadFile(GrayStream.FINISH_OUTPUT, "gray-streams-java");
332    Autoload.autoloadFile(GrayStream.FILE_POSITION, "gray-streams-java");
333    Autoload.autoloadFile(GrayStream.SET_FILE_POSITION, "gray-streams-java");
334    Autoload.autoloadFile(GrayStream.FILE_LENGTH, "gray-streams-java");
335    Autoload.autoloadFile(GrayStream.FILE_STRING_LENGTH, "gray-streams-java");
336    Autoload.autoloadFile(GrayStream.PATHNAME, "gray-streams-java");
337    Autoload.autoloadFile(GrayStream.LINE_COLUMN, "gray-streams-java");
338  }
339}
Note: See TracBrowser for help on using the repository browser.