orelang.operator.FileClass source code

1 module orelang.operator.FileClass;
2 import orelang.expression.ClassType,
3        orelang.operator.IOperator,
4        orelang.Engine,
5        orelang.Value;
6 
7 import std.stdio,
8        std.conv;
9 
10 class FileClass : ClassType {
11   File fp;
12 
13   this (Engine _engine) {
14     _engine = _engine.clone;
15     super("FileClass", _engine);
16 
17     _engine.defineVariable("constructor", new Value(cast(IOperator)(
18       new class () IOperator {
19         public Value call(Engine engine, Value[] args) {
20           string fileName = engine.eval(args[0]).getString,
21                  openType = engine.eval(args[1]).getString;
22           fp.open(fileName, openType);
23           return new Value;
24         }
25       })));
26 
27     _engine.defineVariable("raw-read", new Value(cast(IOperator)(
28       new class () IOperator {
29         public Value call(Engine engine, Value[] args) {
30           Value[] ret;
31           ubyte[] buf;
32           buf.length = fp.size;
33           fp.rawRead(buf);
34 
35           foreach (e; buf) {
36             ret ~= new Value(e);
37           }
38 
39           return new Value(ret);
40         }})));
41 
42     _engine.defineVariable("raw-write", new Value(cast(IOperator)(
43       new class () IOperator {
44         public Value call(Engine engine, Value[] args) {
45           Value[] data = engine.eval(args[0]).getArray;
46           ubyte[] buf;
47 
48           foreach (e; data) {
49             switch (e.type) with (ValueType) {
50               case Numeric:
51                 buf ~= e.getNumeric.to!ubyte;
52                 break;
53               case Ubyte:
54                 buf ~= e.getUbyte;
55                 break;
56               case String:
57                 buf ~= e.getString.to!(ubyte[]);
58                 break;
59               default:
60                 throw new Error("[raw-write] can't write non numeric/ubyte/string value"); 
61             }
62           }
63 
64           fp.rawWrite(buf);
65           return new Value(data);
66         }})));
67 
68     _engine.defineVariable("write", new Value(cast(IOperator)(
69       new class () IOperator {
70         public Value call(Engine engine, Value[] args) {
71           Value data = engine.eval(args[0]);
72 
73           switch (data.type) with (ValueType) {
74             case Numeric:
75               fp.write(data.getNumeric);
76               break;
77             case Ubyte:
78               fp.write(data.getUbyte);
79               break;
80             case String:
81               fp.write(data.getString);
82               break;
83             default:
84               throw new Error("[raw-write] can't write non numeric/ubyte/string value"); 
85           }
86 
87           return data;
88         }})));
89 
90     _engine.defineVariable("writeln", new Value(cast(IOperator)(
91       new class () IOperator {
92         public Value call(Engine engine, Value[] args) {
93           Value data = engine.eval(args[0]);
94 
95           switch (data.type) with (ValueType) {
96             case Numeric:
97               fp.writeln(data.getNumeric);
98               break;
99             case Ubyte:
100               fp.writeln(data.getUbyte);
101               break;
102             case String:
103               fp.writeln(data.getString);
104               break;
105             default:
106               throw new Error("[raw-writeln] can't write non numeric/ubyte/string value"); 
107           }
108 
109           return new Value;
110         }})));
111 
112     _engine.defineVariable("readln", new Value(cast(IOperator)(
113       new class () IOperator {
114         public Value call(Engine engine, Value[] args) {
115           return new Value(fp.readln);
116         }})));
117 
118     _engine.defineVariable("readall", new Value(cast(IOperator)(
119       new class () IOperator {
120         public Value call(Engine engine, Value[] args) {
121           import std..string;
122           string[] buf;
123           foreach (line; fp.byLine) {
124             buf ~= line.to!string;
125           }
126           return new Value(buf.join("\n"));
127         }})));
128   }
129 }