History

big IO binary mode update; now support reading/writing signed and unsigned integers

Ge Wang committed 3 years ago

Commit 52e11991 parent f45b9f77 files · +769 −199Browse files

Unified · Split

7 files
  1. examples/io/read-byte.ck +4 −1
  2. examples/io/read-wav-raw.ck +149 −0
  3. notes/VERSIONS +22 −8
  4. src/core/chuck_io.cpp +300 −115
  5. src/core/chuck_io.h +9 −2
  6. src/core/chuck_oo.cpp +263 −71
  7. src/core/chuck_oo.h +22 −2
examples/io/read-byte.ck+4−1
@@ -28,8 +28,11 @@ int val; · 27 unmodified lines
28while( fio.more() )28while( fio.more() )
29{29{
30 // read the next byte30 // read the next byte
31 // (other options include IO.INT16 and IO.INT32)
32 fio.readInt( IO.INT8 ) => val;31 fio.readInt( IO.INT8 ) => val;
32 // optionsss ^^^^^^^ | requires chuck-1.5.0.1 or higher
33 // IO.INT8, IO.INT16, IO.INT32 (default to unsigned)
34 // IO.UINT8, IO.UINT16, IO.UINT32 (explicitly unsigned)
35 // IO.SINT6, IO.SINT16, IO.SINT32 (explicitly signed)
33 36
34 // print the value37 // print the value
35 cherr <= val <= IO.newline();38 cherr <= val <= IO.newline();
examples/io/read-wav-raw.ck+149−0
@@ -0,0 +1,149 @@
1//---------------------------------------------------------------------
2// name: read-wav-raw.ck
3// desc: example that illustrates manually parsing and rendering a
4// mono WAV file. This demonstrates using FileIO in binary mode.
5// FYI in practice, use SndBuf for easier audio file playback!
6// requires: chuck-1.5.0.1 or higher
7//
8// author: Perry R. Cook
9// date: Summer 2023
10// credit "saigon44.wav": opening words from /Apocalypse Now/
11//---------------------------------------------------------------------
12
13// warn people what is about to happen
14<<< "raw mono WAV file reader!!", "" >>>;
15
16// default file
17me.dir() + "saigon44.wav" => string filename;
18// look at command line
19if( me.args() > 0 ) me.arg(0) => filename;
20
21// instantiate a file IO object
22FileIO fio;
23
24// open a file for reading in BINARY mode
25fio.open( filename, IO.READ | IO.BINARY );
26// ensure it's ok
27if( !fio.good() )
28{
29 // print error message
30 cherr <= "can't open file: " <= filename <= " for reading..."
31 <= IO.newline();
32 // bail
33 me.exit();
34}
35
36// variable to read into
37int val;
38// header
39"0123456789abcdefghijklmnopqrstuvwxyzABCD" @=> string header;
40
41// .wav header details:
42// struct wavhdr {
43// char riff[4]; /* "RIFF" */
44// int flength; /* file length in bytes */
45// char wave[4]; /* "WAVE" */
46// char fmt[4]; /* "fmt " */
47// int block_size; /* in bytes (generally 16) */
48// short format_tag; /* 1=PCM, 257=Mu-Law, 258=A-Law, 259=ADPCM */
49// short num_chans; /* 1=mono, 2=stereo */
50// int srate; /* Sampling rate in samples per second */
51// int bytes_per_sec; /* bytes per second */
52// short bytes_per_samp; /* 2=16-bit mono, 4=16-bit stereo */
53// short bits_per_samp; /* Number of bits per sample */
54// char data[4]; /* "data" */
55// int dlength; /* data length in bytes (filelength - 44) */
56// };
57
58// read in the WAV file header, field by field
59// FYI since chuck-1.5.0.1, in binary mode, readInt() for IO.INT8,
60// IO.INT16, or IO.INT32 by default returns unsigned integers; to read
61// signed integers, call readInt() with IO.SINT8, IO.SINT16, or IO.SINT32
62// e.g., IO.SINT16 is used below when reading signed 16-bits samples
63
64// "RIFF"
65fio.readInt( IO.INT8 ) => val; header.setCharAt(0,val);
66fio.readInt( IO.INT8 ) => val; header.setCharAt(1,val);
67fio.readInt( IO.INT8 ) => val; header.setCharAt(2,val);
68fio.readInt( IO.INT8 ) => val; header.setCharAt(3,val);
69// file length
70fio.readInt( IO.INT32 ) => int flength;
71// "WAVE"
72fio.readInt( IO.INT8 ) => val; header.setCharAt(8,val);
73fio.readInt( IO.INT8 ) => val; header.setCharAt(9,val);
74fio.readInt( IO.INT8 ) => val; header.setCharAt(10,val);
75fio.readInt( IO.INT8 ) => val; header.setCharAt(11,val);
76// "fmt "
77fio.readInt( IO.INT8 ) => val; header.setCharAt(12,val);
78fio.readInt( IO.INT8 ) => val; header.setCharAt(13,val);
79fio.readInt( IO.INT8 ) => val; header.setCharAt(14,val);
80fio.readInt( IO.INT8 ) => val; header.setCharAt(15,val);
81// file info
82fio.readInt( IO.INT32 ) => int blockSize;
83fio.readInt( IO.INT16 ) => int format;
84fio.readInt( IO.INT16 ) => int numChannels;
85fio.readInt( IO.INT32 ) => int sRate;
86fio.readInt( IO.INT32 ) => int bytesPerSecond;
87fio.readInt( IO.INT16 ) => int bytesPerSample;
88fio.readInt( IO.INT16 ) => int bitsPerSample;
89// "data"
90fio.readInt( IO.INT8 ) => val; header.setCharAt(36,val);
91fio.readInt( IO.INT8 ) => val; header.setCharAt(37,val);
92fio.readInt( IO.INT8 ) => val; header.setCharAt(38,val);
93fio.readInt( IO.INT8 ) => val; header.setCharAt(39,val);
94// size of data region in bytes
95fio.readInt( IO.INT32 ) => int dLength;
96
97<<< "***", header, "***" >>>;
98<<< "---------------------", "" >>>;
99<<< "File Length =", flength >>>;
100<<< "Block Size =", blockSize >>>;
101<<< "Format =", format >>>;
102<<< "Num Chans =", numChannels >>>;
103<<< "Sample Rate =", sRate >>>;
104<<< "Bytes/Sec =", bytesPerSecond >>>;
105<<< "Bytes/Sample =", bytesPerSample >>>;
106<<< "Bits/Sample =", bitsPerSample >>>;
107<<< "Data Length =", dLength >>>;
108<<< "---------------------", "" >>>;
109
110// check
111if( numChannels > 1 )
112{
113 // print error message
114 <<< "WAV file contains", numChannels, "channels..." >>>;
115 <<< "this examples only supports mono WAV files...", "" >>>;
116 // bail
117 me.exit();
118}
119
120// render the waveform
121Impulse imp => dac;
122// number of samples
123dLength / bytesPerSample => int numSamples;
124// array
125float samples[numSamples];
126// sample number
1270 => int n;
128
129// loop until end
130while( n < numSamples )
131// while( fio.more() )
132// (^ this may not always work; WAV files may contain debris beyond data region)
133{
134 // read the next sample: signed 16-bit integer
135 fio.readInt( IO.SINT16 ) => int sample;
136 // map sample value from [-32768,32767] to [-1,1]
137 Math.remap(sample, -32768, 32767, -1, 1) => samples[n++] => imp.next;
138 // print dot every 1000 samples
139 if( n % 1000 == 0 ) {
140 chout <= "."; chout.flush();
141 }
142 // print marker every second
143 if( n % sRate == 0 ) {
144 chout <= "|"; chout.flush();
145 }
146
147 // advance one sample
148 samp => now;
149}
notes/VERSIONS+22−8
@@ -6,21 +6,35 @@ ChucK VERSIONS log · 5 unmodified lines
6---6---
7* (added) WvOut support for multiple bit-depths: 16-bit signed int,7* (added) WvOut support for multiple bit-depths: 16-bit signed int,
8 24-bit signed int, 32-bit signed int, 32-bit float, 64-bit float8 24-bit signed int, 32-bit signed int, 32-bit float, 64-bit float
9* these can optionally specified in the newly overloaded WvOut methods:9* (added) the above can be optionally specified in new overloaded WvOut methods:
10 string aifFilename( string value, int datatype );10 string aifFilename( string value, int datatype );
11 Open an AIFF file for writing, with datatype (e.g., IO.INT16,11 Open an AIFF file for writing, with datatype (e.g., IO.INT16,
12 IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).12 IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).
13 string matFilename( string value, int datatype );
14 Open MATLAB file for writing; datatype for MATLAB files can
15 only be IO.FLOAT64.
16 string sndFilename( string value, int datatype );13 string sndFilename( string value, int datatype );
17 Open SND file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).14 Open SND file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32,
15 IO.FLOAT32, IO.FLOAT64).
18 string wavFilename( string value, int datatype );16 string wavFilename( string value, int datatype );
19 Open WAVE file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).17 Open WAVE file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).
18 string matFilename( string value, int datatype );
19 Open MATLAB file for writing; NOTE: datatype for MATLAB files can
20 only be IO.FLOAT64.
20 string rawFilename( string value, int datatype );21 string rawFilename( string value, int datatype );
21 Open a RAW file for writing; datatype for raw files can22 Open a RAW file for writing; NOTE: datatype for raw files can
22 only be IO.INT16.23 only be IO.INT16
23* (added) IO.INT24, IO.INT64, IO.FLOAT32, IO.FLOAT64 IO flags24* (added) examples/stk/wvout-24bit.ck shows writing to a 24-bit audio file
25* (added) new IO flags: IO.INT24, IO.INT64, IO.FLOAT32, IO.FLOAT64
26 IO.UINT8, IO.SINT8, IO.UINT16, IO.SINT16, IO.UINT32, IO.SINT32,
27 IO.UINT64, IO.SINT64
28* (updated) BINARY mode for IO now able to read signed vs. unsigned integers,
29 specified using using .readtInt( flags ), where 'flags' is one of the above
30 IO flags; in BINARY mode, IO.INT8/16/32 now returns unsigned integers, same as
31 IO.UINT8/16/32; to read in signed two's complement integers, use the new
32 IO.SINT8/16/32/64 flags
33* (added) FileIO.readFloat( int flags) and FileIO.write( float val, int flags )
34 these overloaded versions of readFloat() and write() respectively have a 'flags'
35 argument to specify the kind of float (IO.FLOAT32 or IO.FLOAT64)
36* (added) examples/io/read-wav-raw.ck -- illustrates directly parsing a WAV file
37 using FileIO in binary mode (author: Perry R. Cook)
24* (added) examples/special/scream-o-matic/ -- using LiSa + granular38* (added) examples/special/scream-o-matic/ -- using LiSa + granular
25 synthesis for a scream texture generator.39 synthesis for a scream texture generator.
26* (updated) on Linux, better default runtime driver selection for 40* (updated) on Linux, better default runtime driver selection for
src/core/chuck_io.cpp+300−115
@@ -105,93 +105,78 @@ t_CKBOOL init_class_io( Chuck_Env * env, Chuck_Type * type ) · 104 unmodified lines
105 return FALSE;105 return FALSE;
106 106
107 // add good()107 // add good()
108 func = make_new_mfun( "int", "good", io_dummy );108 func = make_new_mfun( "int", "good", io_dummy_int );
109 func->doc = "Returns whether IO is ready for reading.";109 func->doc = "Returns whether IO is ready for reading.";
110 if( !type_engine_import_mfun( env, func ) ) goto error;110 if( !type_engine_import_mfun( env, func ) ) goto error;
111 111
112 // add close()112 // add close()
113 func = make_new_mfun( "void", "close", io_dummy );113 func = make_new_mfun( "void", "close", io_dummy_void );
114 func->doc = "Close the currently open IO.";114 func->doc = "Close the currently open IO.";
115 if( !type_engine_import_mfun( env, func ) ) goto error;115 if( !type_engine_import_mfun( env, func ) ) goto error;
116 116
117 // add flush()117 // add flush()
118 func = make_new_mfun( "void", "flush", io_dummy );118 func = make_new_mfun( "void", "flush", io_dummy_void );
119 func->doc = "Write any buffered output.";119 func->doc = "Write any buffered output.";
120 if( !type_engine_import_mfun( env, func ) ) goto error;120 if( !type_engine_import_mfun( env, func ) ) goto error;
121 121
122 // add mode(int)122 // add mode(int)
123 func = make_new_mfun( "int", "mode", io_dummy );123 func = make_new_mfun( "int", "mode", io_dummy_int );
124 func->add_arg( "int", "flag" );124 func->add_arg( "int", "flag" );
125 func->doc = "Set the current IO mode; either IO.MODE_ASYNC or IO.MODE_SYNC.";125 func->doc = "Set the current IO mode; either IO.MODE_ASYNC or IO.MODE_SYNC.";
126 if( !type_engine_import_mfun( env, func ) ) goto error;126 if( !type_engine_import_mfun( env, func ) ) goto error;
127 127
128 // add mode()128 // add mode()
129 func = make_new_mfun( "int", "mode", io_dummy );129 func = make_new_mfun( "int", "mode", io_dummy_int );
130 func->doc = "Get the current IO mode; either IO.MODE_ASYNC or IO.MODE_SYNC.";130 func->doc = "Get the current IO mode; either IO.MODE_ASYNC or IO.MODE_SYNC.";
131 if( !type_engine_import_mfun( env, func ) ) goto error;131 if( !type_engine_import_mfun( env, func ) ) goto error;
132 132
133 // TODO: add this later?133 // TODO: add this later?
134 // add read()134 // add read()
135 // func = make_new_mfun( "string", "read", io_dummy );135 // func = make_new_mfun( "string", "read", io_dummy_string );
136 // func->add_arg( "int", "length" );136 // func->add_arg( "int", "length" );
137 // if( !type_engine_import_mfun( env, func ) ) goto error;137 // if( !type_engine_import_mfun( env, func ) ) goto error;
138 138
139 // add readLine()139 // add readLine()
140 func = make_new_mfun( "string", "readLine", io_dummy );140 func = make_new_mfun( "string", "readLine", io_dummy_string );
141 func->doc = "Read until an end-of-line character.";141 func->doc = "Read until an end-of-line character.";
142 if( !type_engine_import_mfun( env, func ) ) goto error;142 if( !type_engine_import_mfun( env, func ) ) goto error;
143 143
144 // add readInt()144 // add readInt()
145 func = make_new_mfun( "int", "readInt", io_dummy );145 func = make_new_mfun( "int", "readInt", io_dummy_int );
146 func->add_arg( "int", "flags" );146 func->add_arg( "int", "flags" );
147 func->doc = "Read and return the next integer (binary mode); 'flags' denotes the bit-size of int (IO.INT8, IO.INT16, or IO.INT32).";147 func->doc = "Read and return the next integer; binary mode: 'flags' denotes the bit-size of int (IO.INT8, IO.INT16, or IO.INT32).";
148 if( !type_engine_import_mfun( env, func ) ) goto error;148 if( !type_engine_import_mfun( env, func ) ) goto error;
149 149
150 /*150 // add readFloat()
151 // add readInt()151 func = make_new_mfun( "float", "readFloat", io_dummy_float );
152 func = make_new_mfun( "int", "readInt8", io_dummy );
153 func->add_arg( "int", "flags" );
154 if( !type_engine_import_mfun( env, func ) ) goto error;
155
156 // add readInt()
157 func = make_new_mfun( "int", "readInt16", io_dummy );
158 func->add_arg( "int", "flags" );
159 if( !type_engine_import_mfun( env, func ) ) goto error;
160
161 // add readInt()
162 func = make_new_mfun( "int", "readInt32", io_dummy );
163 func->add_arg( "int", "flags" );152 func->add_arg( "int", "flags" );
153 func->doc = "Read and return the next floating point value; binary mode: 'flags' denotes the size of float to read (IO.FLOAT32 or IO.FLOAT64).";
164 if( !type_engine_import_mfun( env, func ) ) goto error;154 if( !type_engine_import_mfun( env, func ) ) goto error;
165 */
166
167 // add readFloat()
168 // func = make_new_mfun( "float", "readFloat", io_dummy );
169 // if( !type_engine_import_mfun( env, func ) ) goto error;
170 155
171 // add eof()156 // add eof()
172 func = make_new_mfun( "int", "eof", io_dummy );157 func = make_new_mfun( "int", "eof", io_dummy_int );
173 func->doc = "Return whether end-of-file has been reached; the opposite of .more().";158 func->doc = "Return whether end-of-file has been reached; the opposite of .more().";
174 if( !type_engine_import_mfun( env, func ) ) goto error;159 if( !type_engine_import_mfun( env, func ) ) goto error;
175 160
176 // add more()161 // add more()
177 func = make_new_mfun( "int", "more", io_dummy );162 func = make_new_mfun( "int", "more", io_dummy_int );
178 func->doc = "Return whether there is more to read; the opposite of .eof().";163 func->doc = "Return whether there is more to read; the opposite of .eof().";
179 if( !type_engine_import_mfun( env, func ) ) goto error;164 if( !type_engine_import_mfun( env, func ) ) goto error;
180 165
181 // add write(string)166 // add write(string)
182 func = make_new_mfun( "void", "write", io_dummy );167 func = make_new_mfun( "void", "write", io_dummy_void );
183 func->add_arg( "string", "val" );168 func->add_arg( "string", "val" );
184 func->doc = "Write string 'val'.";169 func->doc = "Write string 'val'.";
185 if( !type_engine_import_mfun( env, func ) ) goto error;170 if( !type_engine_import_mfun( env, func ) ) goto error;
186 171
187 // add write(int)172 // add write(int)
188 func = make_new_mfun( "void", "write", io_dummy );173 func = make_new_mfun( "void", "write", io_dummy_void );
189 func->add_arg( "int", "val" );174 func->add_arg( "int", "val" );
190 func->doc = "Write integer 'val'.";175 func->doc = "Write integer 'val'.";
191 if( !type_engine_import_mfun( env, func ) ) goto error;176 if( !type_engine_import_mfun( env, func ) ) goto error;
192 177
193 // add write(float)178 // add write(float)
194 func = make_new_mfun( "void", "write", io_dummy );179 func = make_new_mfun( "void", "write", io_dummy_void );
195 func->add_arg( "float", "val" );180 func->add_arg( "float", "val" );
196 func->doc = "Write floating point number 'val'.";181 func->doc = "Write floating point number 'val'.";
197 if( !type_engine_import_mfun( env, func ) ) goto error;182 if( !type_engine_import_mfun( env, func ) ) goto error;
@@ -233,21 +218,42 @@ t_CKBOOL init_class_io( Chuck_Env * env, Chuck_Type * type ) · 35 unmodified lines
233 // add INT64 | 1.5.0.1 (ge) added218 // add INT64 | 1.5.0.1 (ge) added
234 if( !type_engine_import_svar( env, "int", "INT64",219 if( !type_engine_import_svar( env, "int", "INT64",
235 TRUE, (t_CKUINT)&Chuck_IO::INT64, "Flag denoting 64-bit integer type." ) ) goto error;220 TRUE, (t_CKUINT)&Chuck_IO::INT64, "Flag denoting 64-bit integer type." ) ) goto error;
221 // add SINT8 | 1.5.0.1 (ge) added
222 if( !type_engine_import_svar( env, "int", "SINT8",
223 TRUE, (t_CKUINT)&Chuck_IO::SINT8, "Flag denoting 8-bit signed integer type." ) ) goto error;
224 // add SINT16 | 1.5.0.1 (ge) added
225 if( !type_engine_import_svar( env, "int", "SINT16",
226 TRUE, (t_CKUINT)&Chuck_IO::SINT16, "Flag denoting 16-bit signed integer type." ) ) goto error;
227 // add SINT24 | 1.5.0.1 (ge) added
228 if( !type_engine_import_svar( env, "int", "SINT24",
229 TRUE, (t_CKUINT)&Chuck_IO::SINT24, "Flag denoting 24-bit signed integer type." ) ) goto error;
230 // add SINT32 | 1.5.0.1 (ge) added
231 if( !type_engine_import_svar( env, "int", "SINT32",
232 TRUE, (t_CKUINT)&Chuck_IO::SINT32, "Flag denoting 32-bit signed integer type." ) ) goto error;
233 // add SINT64 | 1.5.0.1 (ge) added
234 if( !type_engine_import_svar( env, "int", "SINT64",
235 TRUE, (t_CKUINT)&Chuck_IO::SINT64, "Flag denoting 64-bit signed integer type." ) ) goto error;
236 // add UINT8 | 1.5.0.1 (ge) added
237 if( !type_engine_import_svar( env, "int", "UINT8",
238 TRUE, (t_CKUINT)&Chuck_IO::UINT8, "Flag denoting 8-bit unsigned integer type." ) ) goto error;
239 // add UINT16 | 1.5.0.1 (ge) added
240 if( !type_engine_import_svar( env, "int", "UINT16",
241 TRUE, (t_CKUINT)&Chuck_IO::UINT16, "Flag denoting 16-bit unsigned integer type." ) ) goto error;
242 // add UINT24 | 1.5.0.1 (ge) added
243 if( !type_engine_import_svar( env, "int", "UINT24",
244 TRUE, (t_CKUINT)&Chuck_IO::UINT24, "Flag denoting 24-bit unsigned integer type." ) ) goto error;
245 // add UINT32 | 1.5.0.1 (ge) added
246 if( !type_engine_import_svar( env, "int", "UINT32",
247 TRUE, (t_CKUINT)&Chuck_IO::UINT32, "Flag denoting 32-bit unsigned integer type." ) ) goto error;
248 // add UINT64 | 1.5.0.1 (ge) added
249 if( !type_engine_import_svar( env, "int", "UINT64",
250 TRUE, (t_CKUINT)&Chuck_IO::UINT64, "Flag denoting 64-bit unsigned integer type." ) ) goto error;
236 // add FLOAT32 | 1.5.0.1 (ge) added251 // add FLOAT32 | 1.5.0.1 (ge) added
237 if( !type_engine_import_svar( env, "int", "FLOAT32",252 if( !type_engine_import_svar( env, "int", "FLOAT32",
238 TRUE, (t_CKUINT)&Chuck_IO::FLOAT32, "Flag denoting 32-bit floating point type." ) ) goto error;253 TRUE, (t_CKUINT)&Chuck_IO::FLOAT32, "Flag denoting 32-bit floating point type." ) ) goto error;
239 // add FLOAT64 | 1.5.0.1 (ge) added254 // add FLOAT64 | 1.5.0.1 (ge) added
240 if( !type_engine_import_svar( env, "int", "FLOAT64",255 if( !type_engine_import_svar( env, "int", "FLOAT64",
241 TRUE, (t_CKUINT)&Chuck_IO::FLOAT64, "Flag denoting 64-bit floating point type." ) ) goto error;256 TRUE, (t_CKUINT)&Chuck_IO::FLOAT64, "Flag denoting 64-bit floating point type." ) ) goto error;
242// // add READ_INT8
243// if( !type_engine_import_svar( env, "int", "READ_INT8",
244// TRUE, (t_CKUINT)&Chuck_IO::INT8, "Flag denoting 8-bit integer type (same as INT8)." ) ) goto error;
245// // add READ_INT16
246// if( !type_engine_import_svar( env, "int", "READ_INT16",
247// TRUE, (t_CKUINT)&Chuck_IO::INT16, "Flag denoting 16-bit integer type (same as INT16)." ) ) goto error;
248// // add READ_INT32
249// if( !type_engine_import_svar( env, "int", "READ_INT32",
250// TRUE, (t_CKUINT)&Chuck_IO::INT32, "Flag denoting 32-bit integer type (same as INT32)." ) ) goto error;
251 // add MODE_SYNC257 // add MODE_SYNC
252 if( !type_engine_import_svar( env, "int", "MODE_SYNC",258 if( !type_engine_import_svar( env, "int", "MODE_SYNC",
253 TRUE, (t_CKUINT)&Chuck_IO::MODE_SYNC, "Flag denoting synchronous IO." ) ) goto error;259 TRUE, (t_CKUINT)&Chuck_IO::MODE_SYNC, "Flag denoting synchronous IO." ) ) goto error;
@@ -387,34 +393,19 @@ t_CKBOOL init_class_fileio( Chuck_Env * env, Chuck_Type * type ) · 133 unmodified lines
387 // add readInt(int)393 // add readInt(int)
388 func = make_new_mfun( "int", "readInt", fileio_readintflags );394 func = make_new_mfun( "int", "readInt", fileio_readintflags );
389 func->add_arg( "int", "flags" );395 func->add_arg( "int", "flags" );
390 func->doc = "Read and return an integer by size (binary mode) as specified in 'flags' (IO.INT8, IO.INT16, IO.INT32).";396 func->doc = "Read and return an integer; binary mode: 'flags' specifies int size to read (IO.INT8, IO.INT16, IO.INT32 default to unsigned values; for signed integers use IO.SINT8, IO.SINT16, IO.SINT32).";
391 if( !type_engine_import_mfun( env, func ) ) goto error;
392
393 /*
394 // add readByte()
395 func = make_new_mfun( "int", "readByte", fileio_readint8 );
396 func->add_arg( "int", "flags" );
397 if( !type_engine_import_mfun( env, func ) ) goto error;
398
399 // add readInt8()
400 func = make_new_mfun( "int", "readInt8", fileio_readint8 );
401 func->add_arg( "int", "flags" );
402 if( !type_engine_import_mfun( env, func ) ) goto error;397 if( !type_engine_import_mfun( env, func ) ) goto error;
403 398
404 // add readInt16()399 // add readFloat()
405 func = make_new_mfun( "int", "readInt16", fileio_readint16 );400 func = make_new_mfun( "float", "readFloat", fileio_readfloat );
406 func->add_arg( "int", "flags" );401 func->doc = "Read and return the next floating point value.";
407 if( !type_engine_import_mfun( env, func ) ) goto error;402 if( !type_engine_import_mfun( env, func ) ) goto error;
408 403
409 // add readInt32()404 // add readFloat()
410 func = make_new_mfun( "int", "readInt32", fileio_readint32 );405 func = make_new_mfun( "float", "readFloat", fileio_readfloatflags );
411 func->add_arg( "int", "flags" );406 func->add_arg( "int", "flags" );
407 func->doc = "Read and return the next floating point value; if binary mode: 'flags' denotes the size of float to read (IO.FLOAT32 or IO.FLOAT64).";
412 if( !type_engine_import_mfun( env, func ) ) goto error;408 if( !type_engine_import_mfun( env, func ) ) goto error;
413 */
414
415 // add readFloat()
416 // func = make_new_mfun( "float", "readFloat", fileio_readfloat );
417 // if( !type_engine_import_mfun( env, func ) ) goto error;
418 409
419 // add eof()410 // add eof()
420 func = make_new_mfun( "int", "eof", fileio_eof );411 func = make_new_mfun( "int", "eof", fileio_eof );
@@ -442,13 +433,20 @@ t_CKBOOL init_class_fileio( Chuck_Env * env, Chuck_Type * type ) · 21 unmodified lines
442 func = make_new_mfun( "void", "write", fileio_writeintflags );433 func = make_new_mfun( "void", "write", fileio_writeintflags );
443 func->add_arg( "int", "val" );434 func->add_arg( "int", "val" );
444 func->add_arg( "int", "flags" );435 func->add_arg( "int", "flags" );
445 func->doc = "Write integer to file (binary mode) by size as specified by 'flags' (IO.INT8, IO.INT16, IO.INT32).";436 func->doc = "Write integer value to file; binary mode: int size specified by 'flags' (IO.INT8, IO.INT16, IO.INT32).";
446 if( !type_engine_import_mfun( env, func ) ) goto error;437 if( !type_engine_import_mfun( env, func ) ) goto error;
447 438
448 // add write(float)439 // add write(float)
449 func = make_new_mfun( "void", "write", fileio_writefloat );440 func = make_new_mfun( "void", "write", fileio_writefloat );
450 func->add_arg( "float", "val" );441 func->add_arg( "float", "val" );
451 func->doc = "Write integer to file.";442 func->doc = "Write floating point value to file.";
443 if( !type_engine_import_mfun( env, func ) ) goto error;
444
445 // add write(float)
446 func = make_new_mfun( "void", "write", fileio_writefloatflags );
447 func->add_arg( "float", "val" );
448 func->add_arg( "int", "flags" );
449 func->doc = "Write floating point value to file; binary mode: flags indicate float size (IO.FLOAT32 or IO.FLOAT64).";
452 if( !type_engine_import_mfun( env, func ) ) goto error;450 if( !type_engine_import_mfun( env, func ) ) goto error;
453 451
454 // add examples452 // add examples
@@ -522,10 +520,6 @@ t_CKBOOL init_class_chout( Chuck_Env * env, Chuck_Type * type ) · 67 unmodified lines
522 func = make_new_mfun( "string", "readLine", chout_readline );520 func = make_new_mfun( "string", "readLine", chout_readline );
523 if( !type_engine_import_mfun( env, func ) ) goto error;521 if( !type_engine_import_mfun( env, func ) ) goto error;
524 522
525 // add readInt()
526 // func = make_new_mfun( "int", "readInt", chout_readint );
527 // if( !type_engine_import_mfun( env, func ) ) goto error;
528
529 // add readInt(int)523 // add readInt(int)
530 func = make_new_mfun( "int", "readInt", chout_readintflags );524 func = make_new_mfun( "int", "readInt", chout_readintflags );
531 func->add_arg( "int", "flags" );525 func->add_arg( "int", "flags" );
@@ -533,6 +527,7 @@ t_CKBOOL init_class_chout( Chuck_Env * env, Chuck_Type * type ) · 1 unmodified line
533 527
534 // add readFloat()528 // add readFloat()
535 // func = make_new_mfun( "float", "readFloat", chout_readfloat );529 // func = make_new_mfun( "float", "readFloat", chout_readfloat );
530 // func->add_arg( "int", "flags" );
536 // if( !type_engine_import_mfun( env, func ) ) goto error;531 // if( !type_engine_import_mfun( env, func ) ) goto error;
537 532
538 // add eof()533 // add eof()
@@ -615,17 +610,14 @@ t_CKBOOL init_class_cherr( Chuck_Env * env, Chuck_Type * type ) · 76 unmodified lines
615 func = make_new_mfun( "string", "readLine", cherr_readline );610 func = make_new_mfun( "string", "readLine", cherr_readline );
616 if( !type_engine_import_mfun( env, func ) ) goto error;611 if( !type_engine_import_mfun( env, func ) ) goto error;
617 612
618 // add readInt()
619 // func = make_new_mfun( "int", "readInt", cherr_readint );
620 // if( !type_engine_import_mfun( env, func ) ) goto error;
621
622 // add readInt(int)613 // add readInt(int)
623 func = make_new_mfun( "int", "readInt", cherr_readintflags );614 // func = make_new_mfun( "int", "readInt", cherr_readintflags );
624 func->add_arg( "int", "flags" );615 // func->add_arg( "int", "flags" );
625 if( !type_engine_import_mfun( env, func ) ) goto error;616 // if( !type_engine_import_mfun( env, func ) ) goto error;
626 617
627 // add readFloat()618 // add readFloat()
628 // func = make_new_mfun( "float", "readFloat", cherr_readfloat );619 // func = make_new_mfun( "float", "readFloat", cherr_readfloat );
620 // func->add_arg( "int", "flags" );
629 // if( !type_engine_import_mfun( env, func ) ) goto error;621 // if( !type_engine_import_mfun( env, func ) ) goto error;
630 622
631 // add eof()623 // add eof()
@@ -1507,14 +1499,31 @@ error: · 875 unmodified lines
1507//-----------------------------------------------------------------------------1499//-----------------------------------------------------------------------------
1508// IO API1500// IO API
1509//-----------------------------------------------------------------------------1501//-----------------------------------------------------------------------------
1510CK_DLL_MFUN( io_dummy )1502CK_DLL_MFUN( io_dummy_int )
1511{1503{
1512 EM_error3( "(IO): internal error! inside an abstract function! help!" );1504 // EM_error3( "(IO): internal error! inside an abstract function! help!" );
1513 EM_error3( " note: please hunt down someone (e.g., Ge) to fix this..." );1505 // EM_error3( " note: please hunt down someone (e.g., Ge) to fix this..." );
1514 assert( FALSE );1506 // assert( FALSE );
1515 RETURN->v_int = 0;1507 RETURN->v_int = 0;
1516}1508}
1517 1509
1510CK_DLL_MFUN( io_dummy_float )
1511{
1512 // return 0.0
1513 RETURN->v_float = 0;
1514}
1515
1516CK_DLL_MFUN( io_dummy_string )
1517{
1518 // return NULL
1519 RETURN->v_string = NULL;
1520}
1521
1522CK_DLL_MFUN( io_dummy_void )
1523{
1524 // do nothing
1525}
1526
1518CK_DLL_SFUN( io_newline )1527CK_DLL_SFUN( io_newline )
1519{1528{
1520 RETURN->v_string = g_newline;1529 RETURN->v_string = g_newline;
@@ -1681,21 +1690,18 @@ CK_DLL_MFUN( fileio_readintflags ) · 160 unmodified lines
1681 1690
1682CK_DLL_MFUN( fileio_readint8 )1691CK_DLL_MFUN( fileio_readint8 )
1683{1692{
1684 t_CKINT flags = GET_NEXT_INT(ARGS);
1685 Chuck_IO_File * f = (Chuck_IO_File *)SELF;1693 Chuck_IO_File * f = (Chuck_IO_File *)SELF;
1686 RETURN->v_int = f->readInt( Chuck_IO::INT8 );1694 RETURN->v_int = f->readInt( Chuck_IO::INT8 );
1687}1695}
1688 1696
1689CK_DLL_MFUN( fileio_readint16 )1697CK_DLL_MFUN( fileio_readint16 )
1690{1698{
1691 t_CKINT flags = GET_NEXT_INT(ARGS);
1692 Chuck_IO_File * f = (Chuck_IO_File *)SELF;1699 Chuck_IO_File * f = (Chuck_IO_File *)SELF;
1693 RETURN->v_int = f->readInt( Chuck_IO::INT16 );1700 RETURN->v_int = f->readInt( Chuck_IO::INT16 );
1694}1701}
1695 1702
1696CK_DLL_MFUN( fileio_readint32 )1703CK_DLL_MFUN( fileio_readint32 )
1697{1704{
1698 t_CKINT flags = GET_NEXT_INT(ARGS);
1699 Chuck_IO_File * f = (Chuck_IO_File *)SELF;1705 Chuck_IO_File * f = (Chuck_IO_File *)SELF;
1700 RETURN->v_int = f->readInt( Chuck_IO::INT32 );1706 RETURN->v_int = f->readInt( Chuck_IO::INT32 );
1701}1707}
@@ -1703,8 +1709,14 @@ CK_DLL_MFUN( fileio_readint32 ) · 1 unmodified line
1703CK_DLL_MFUN( fileio_readfloat )1709CK_DLL_MFUN( fileio_readfloat )
1704{1710{
1705 Chuck_IO_File * f = (Chuck_IO_File *)SELF;1711 Chuck_IO_File * f = (Chuck_IO_File *)SELF;
1706 t_CKFLOAT ret = f->readFloat();1712 RETURN->v_float = f->readFloat();
1707 RETURN->v_float = ret;1713}
1714
1715CK_DLL_MFUN( fileio_readfloatflags )
1716{
1717 Chuck_IO_File * f = (Chuck_IO_File *)SELF;
1718 t_CKINT flags = GET_NEXT_INT(ARGS);
1719 RETURN->v_float = f->readFloat( flags );
1708}1720}
1709 1721
1710CK_DLL_MFUN( fileio_eof )1722CK_DLL_MFUN( fileio_eof )
@@ -1835,6 +1847,7 @@ CK_DLL_MFUN( fileio_writeintflags ) · 124 unmodified lines
1835CK_DLL_MFUN( fileio_writefloat )1847CK_DLL_MFUN( fileio_writefloat )
1836{1848{
1837 t_CKFLOAT val = GET_NEXT_FLOAT(ARGS);1849 t_CKFLOAT val = GET_NEXT_FLOAT(ARGS);
1850 t_CKINT flagsDefault = Chuck_IO::FLOAT32;
1838 Chuck_IO_File * f = (Chuck_IO_File *)SELF;1851 Chuck_IO_File * f = (Chuck_IO_File *)SELF;
1839 1852
1840#ifndef __DISABLE_FILEIO__ // 1.5.0.0 (ge) | made more granular (e.g., for WebChucK)1853#ifndef __DISABLE_FILEIO__ // 1.5.0.0 (ge) | made more granular (e.g., for WebChucK)
@@ -1845,6 +1858,7 @@ CK_DLL_MFUN( fileio_writefloat ) · 4 unmodified lines
1845 args->RETURN = (void *)RETURN;1858 args->RETURN = (void *)RETURN;
1846 args->fileio_obj = f;1859 args->fileio_obj = f;
1847 args->floatArg = val;1860 args->floatArg = val;
1861 args->intArg = flagsDefault; // 1.5.0.1 (ge) add default
1848 // set shred to wait for I/O completion1862 // set shred to wait for I/O completion
1849 assert( SHRED != NULL );1863 assert( SHRED != NULL );
1850 f->m_asyncEvent->wait( SHRED, SHRED->vm_ref );1864 f->m_asyncEvent->wait( SHRED, SHRED->vm_ref );
@@ -1861,10 +1875,48 @@ CK_DLL_MFUN( fileio_writefloat ) · 10 unmodified lines
1861 }1875 }
1862 }1876 }
1863 } else {1877 } else {
1864 f->write(val);1878 f->write( val, flagsDefault );
1865 }1879 }
1866#else1880#else
1867 f->write(val);1881 f->write( val, flagsDefault );
1882#endif //__DISABLE_FILEIO__
1883}
1884
1885CK_DLL_MFUN( fileio_writefloatflags )
1886{
1887 t_CKFLOAT val = GET_NEXT_FLOAT(ARGS);
1888 t_CKINT flags = GET_NEXT_INT(ARGS);
1889 Chuck_IO_File * f = (Chuck_IO_File *)SELF;
1890
1891#ifndef __DISABLE_FILEIO__ // 1.5.0.0 (ge) | made more granular (e.g., for WebChucK)
1892 if (f->mode() == Chuck_IO::MODE_ASYNC)
1893 {
1894 // set up arguments
1895 Chuck_IO::async_args *args = new Chuck_IO::async_args;
1896 args->RETURN = (void *)RETURN;
1897 args->fileio_obj = f;
1898 args->floatArg = val;
1899 args->intArg = flags; // 1.5.0.1 (ge) added
1900 // set shred to wait for I/O completion
1901 assert( SHRED != NULL );
1902 f->m_asyncEvent->wait( SHRED, SHRED->vm_ref );
1903 // start thread
1904 bool ret = f->m_thread->start( f->writeFloat_thread, (void *)args );
1905 if (!ret) {
1906 // for some reason, the XThread object needs to be
1907 // deleted and reconstructed every time after call #375
1908 delete f->m_thread;
1909 f->m_thread = new XThread;
1910 ret = f->m_thread->start( f->writeFloat_thread, (void *)args );
1911 if (!ret) {
1912 EM_error3( "(FileIO): failed to start thread for asynchronous mode I/O" );
1913 }
1914 }
1915 } else {
1916 f->write( val,flags );
1917 }
1918#else
1919 f->write( val,flags );
1868#endif //__DISABLE_FILEIO__1920#endif //__DISABLE_FILEIO__
1869}1921}
1870 1922
@@ -3123,7 +3175,7 @@ t_CKINT Chuck_IO_Serial::readInt( t_CKINT flags ) · 1252 unmodified lines
3123 3175
3124 if( m_flags & Chuck_IO::TYPE_BINARY )3176 if( m_flags & Chuck_IO::TYPE_BINARY )
3125 {3177 {
3126 if( flags & INT8 )3178 if( flags & Chuck_IO::INT8 || flags & Chuck_IO::UINT8 ) // 1.5.0.1 (ge) added UINT
3127 {3179 {
3128 uint8_t byte = 0;3180 uint8_t byte = 0;
3129 if(!fread(&byte, 1, 1, m_cfd))3181 if(!fread(&byte, 1, 1, m_cfd))
@@ -3131,7 +3183,7 @@ t_CKINT Chuck_IO_Serial::readInt( t_CKINT flags ) · 1 unmodified line
3131 3183
3132 i = byte;3184 i = byte;
3133 }3185 }
3134 else if( flags & INT16 )3186 else if( flags & Chuck_IO::INT16 || flags & Chuck_IO::UINT16 ) // 1.5.0.1 (ge) added UINT
3135 {3187 {
3136 uint16_t word = 0;3188 uint16_t word = 0;
3137 if(!fread(&word, 2, 1, m_cfd))3189 if(!fread(&word, 2, 1, m_cfd))
@@ -3139,7 +3191,7 @@ t_CKINT Chuck_IO_Serial::readInt( t_CKINT flags ) · 1 unmodified line
3139 3191
3140 i = word;3192 i = word;
3141 }3193 }
3142 else if( flags & INT32 )3194 else if( flags & Chuck_IO::INT32 || flags & Chuck_IO::UINT32 ) // 1.5.0.1 (ge) added UINT
3143 {3195 {
3144 uint32_t dword = 0;3196 uint32_t dword = 0;
3145 if(!fread(&dword, 4, 1, m_cfd))3197 if(!fread(&dword, 4, 1, m_cfd))
@@ -3147,6 +3199,46 @@ t_CKINT Chuck_IO_Serial::readInt( t_CKINT flags ) · 1 unmodified line
3147 3199
3148 i = dword;3200 i = dword;
3149 }3201 }
3202 else if( flags & Chuck_IO::INT64 || flags & Chuck_IO::UINT64 ) // 1.5.0.1 (ge) added UINT and 64-bit
3203 {
3204 uint64_t val = 0;
3205 if(!fread(&val, 8, 1, m_cfd))
3206 EM_log(CK_LOG_WARNING, "(Serial.readInt): error: read failed");
3207
3208 i = val;
3209 }
3210 else if( flags & Chuck_IO::SINT8 ) // 1.5.0.1 (ge) added SINT
3211 {
3212 int8_t byte = 0;
3213 if(!fread(&byte, 1, 1, m_cfd))
3214 EM_log(CK_LOG_WARNING, "(Serial.readInt): error: read failed");
3215
3216 i = byte;
3217 }
3218 else if( flags & Chuck_IO::SINT16 ) // 1.5.0.1 (ge) added SINT
3219 {
3220 int16_t word = 0;
3221 if(!fread(&word, 2, 1, m_cfd))
3222 EM_log(CK_LOG_WARNING, "(Serial.readInt): error: read failed");
3223
3224 i = word;
3225 }
3226 else if( flags & Chuck_IO::SINT32 ) // 1.5.0.1 (ge) added SINT
3227 {
3228 int32_t dword = 0;
3229 if(!fread(&dword, 4, 1, m_cfd))
3230 EM_log(CK_LOG_WARNING, "(Serial.readInt): error: read failed");
3231
3232 i = dword;
3233 }
3234 else if( flags & Chuck_IO::SINT64 ) // 1.5.0.1 (ge) added SINT and 64-bit
3235 {
3236 int64_t val = 0;
3237 if(!fread(&val, 8, 1, m_cfd))
3238 EM_log(CK_LOG_WARNING, "(Serial.readInt): error: read failed");
3239
3240 i = val;
3241 }
3150 }3242 }
3151 else3243 else
3152 {3244 {
@@ -3157,7 +3249,13 @@ t_CKINT Chuck_IO_Serial::readInt( t_CKINT flags ) · 4 unmodified lines
3157 return i;3249 return i;
3158}3250}
3159 3251
3160t_CKFLOAT Chuck_IO_Serial::readFloat()3252t_CKFLOAT Chuck_IO_Serial::readFloat( )
3253{
3254 // 1.5.0.1 (ge) redirect
3255 return readFloat( Chuck_IO::FLOAT32 );
3256}
3257
3258t_CKFLOAT Chuck_IO_Serial::readFloat( t_CKINT flags )
3161{3259{
3162 if( !good() )3260 if( !good() )
3163 {3261 {
@@ -3175,8 +3273,26 @@ t_CKFLOAT Chuck_IO_Serial::readFloat() · 11 unmodified lines
3175 3273
3176 if( m_flags & Chuck_IO::TYPE_BINARY )3274 if( m_flags & Chuck_IO::TYPE_BINARY )
3177 {3275 {
3178 if(!fread(&f, 4, 1, m_cfd))3276 // check size
3179 EM_log(CK_LOG_WARNING, "(Serial.readFloat): error: read failed");3277 if( flags & Chuck_IO::FLOAT32 )
3278 {
3279 float v = 0.0f;
3280 if(!fread(&v, 4, 1, m_cfd))
3281 EM_log(CK_LOG_WARNING, "(Serial.readFloat): error: read failed");
3282 f = v;
3283 }
3284 else if( flags & Chuck_IO::FLOAT64 )
3285 {
3286 double v = 0.0;
3287 if( !fread(&v, 8, 1, m_cfd) )
3288 EM_log(CK_LOG_WARNING, "(Serial.readFloat): error: read failed");
3289 f = v;
3290 }
3291 else
3292 {
3293 // error message
3294 EM_log(CK_LOG_WARNING, "(Serial.readFloat): invalid or unsupported size flag");
3295 }
3180 }3296 }
3181 else3297 else
3182 {3298 {
@@ -3213,7 +3329,7 @@ t_CKBOOL Chuck_IO_Serial::readString( std::string & str ) · 30 unmodified lines
3213 return FALSE;3329 return FALSE;
3214 }3330 }
3215 3331
3216 str = (char *) m_tmp_buf;3332 str = (char *) m_tmp_buf;
3217 3333
3218 return TRUE;3334 return TRUE;
3219}3335}
@@ -3304,11 +3420,11 @@ void Chuck_IO_Serial::write( const std::string & val ) · 84 unmodified lines
3304 3420
3305void Chuck_IO_Serial::write( t_CKINT val )3421void Chuck_IO_Serial::write( t_CKINT val )
3306{3422{
3307 write( val, 4 );3423 write( val, Chuck_IO::INT32 );
3308}3424}
3309 3425
3310 3426
3311void Chuck_IO_Serial::write( t_CKINT val, t_CKINT size )3427void Chuck_IO_Serial::write( t_CKINT val, t_CKINT flags )
3312{3428{
3313 if( !good() )3429 if( !good() )
3314 {3430 {
@@ -3316,9 +3432,11 @@ void Chuck_IO_Serial::write( t_CKINT val, t_CKINT size ) · 1 unmodified line
3316 return;3432 return;
3317 }3433 }
3318 3434
3319 if(!(size == 1 || size == 2 || size == 4 || size == 8))3435 // check flags
3436 if( (flags & Chuck_IO::INT8 ) || (flags & Chuck_IO::INT16) ||
3437 (flags & Chuck_IO::INT32) || (flags & Chuck_IO::INT64) )
3320 {3438 {
3321 EM_log(CK_LOG_WARNING, "(Serial.write): warning: invalid int size %li, ignoring write request", size);3439 EM_log( CK_LOG_WARNING, "(Serial.write): warning: invalid int size flag, ignoring write request" );
3322 return;3440 return;
3323 }3441 }
3324 3442
@@ -3350,11 +3468,23 @@ void Chuck_IO_Serial::write( t_CKINT val, t_CKINT size ) · 25 unmodified lines
3350 }3468 }
3351 else3469 else
3352 {3470 {
3353 char * buf = (char *)&val;3471 // 1.5.0.1 (ge) check and handle individually
3354 3472 uint8_t v8 = (uint8_t)val;
3355 // assume 4-byte int3473 uint16_t v16 = (uint16_t)val;
3474 uint32_t v32 = (uint32_t)val;
3475 uint64_t v64 = (uint64_t)val;
3476 char * buf = NULL;
3477 t_CKINT size = 0;
3478
3479 if( flags & Chuck_IO::INT8 ) { buf = (char *)&v8; size = 1; }
3480 else if( flags & Chuck_IO::INT16 ) { buf = (char *)&v16; size = 2; }
3481 else if( flags & Chuck_IO::INT32 ) { buf = (char *)&v32; size = 4; }
3482 else if( flags & Chuck_IO::INT64 ) { buf = (char *)&v64; size = 8; }
3483 // other size values should be caught above
3484
3485 // put into write buffer
3356 for(int i = 0; i < size; i++)3486 for(int i = 0; i < size; i++)
3357 m_writeBuffer.put(buf[i]);3487 m_writeBuffer.put( buf[i] );
3358 3488
3359 Request r;3489 Request r;
3360 r.m_type = TYPE_WRITE;3490 r.m_type = TYPE_WRITE;
@@ -3373,14 +3503,38 @@ void Chuck_IO_Serial::write( t_CKINT val, t_CKINT size ) · 12 unmodified lines
3373 }3503 }
3374 else3504 else
3375 {3505 {
3376 // assume 4-byte int3506 // 1.5.0.1 (ge) check and handle individually
3377 char * buf = (char *) &val;3507 if( flags & Chuck_IO::INT8 )
3378 fwrite(buf, 1, size, m_cfd);3508 {
3509 uint8_t v = (uint8_t)val;
3510 fwrite( (char*)&v, 1, 1, m_cfd );
3511 }
3512 else if( flags & Chuck_IO::INT16 )
3513 {
3514 uint16_t v = (uint16_t)val;
3515 fwrite( (char*)&v, 1, 2, m_cfd );
3516 }
3517 else if( flags & Chuck_IO::INT32 )
3518 {
3519 uint32_t v = (uint32_t)val;
3520 fwrite( (char*)&v, 1, 4, m_cfd );
3521 }
3522 else if( flags & Chuck_IO::INT64 )
3523 {
3524 uint64_t v = (uint64_t)val;
3525 fwrite( (char*)&v, 1, 8, m_cfd );
3526 }
3527 // other size values should be caught above
3379 }3528 }
3380 }3529 }
3381}3530}
3382 3531
3383void Chuck_IO_Serial::write( t_CKFLOAT val )3532void Chuck_IO_Serial::write( t_CKFLOAT val )
3533{
3534 this->write( val, Chuck_IO::FLOAT32 );
3535}
3536
3537void Chuck_IO_Serial::write( t_CKFLOAT val, t_CKINT flags )
3384{3538{
3385 if( !good() )3539 if( !good() )
3386 {3540 {
@@ -3416,11 +3570,26 @@ void Chuck_IO_Serial::write( t_CKFLOAT val ) · 29 unmodified lines
3416 }3570 }
3417 else3571 else
3418 {3572 {
3419 char * buf = (char *) &val;3573 // 1.5.0.1 (ge) check datatype size flag
3420 3574 if( flags & Chuck_IO::FLOAT32 )
3421 // assume 4-byte float3575 {
3422 for(int i = 0; i < 4; i++)3576 float v = (float)val;
3423 m_writeBuffer.put(buf[i]);3577 char * buf = (char *)&v;
3578 for(int i = 0; i < sizeof(v); i++)
3579 m_writeBuffer.put(buf[i]);
3580 }
3581 else if( flags & Chuck_IO::FLOAT64 )
3582 {
3583 double v = (double)val;
3584 char * buf = (char *)&v;
3585 for(int i = 0; i < sizeof(v); i++)
3586 m_writeBuffer.put(buf[i]);
3587 }
3588 else
3589 {
3590 // error message
3591 EM_log(CK_LOG_WARNING, "(Serial.write): invalid or unsupported size flag");
3592 }
3424 3593
3425 Request r;3594 Request r;
3426 r.m_type = TYPE_WRITE;3595 r.m_type = TYPE_WRITE;
@@ -3437,12 +3606,28 @@ void Chuck_IO_Serial::write( t_CKFLOAT val ) · 10 unmodified lines
3437 {3606 {
3438 fprintf( m_cfd, "%f", val );3607 fprintf( m_cfd, "%f", val );
3439 }3608 }
3440 else3609 else // BINARY
3441 {3610 {
3442 // assume 4-byte int3611 // 1.5.0.1 (ge) check datatype size flag
3443 char * buf = (char *) &val;3612 if( flags & Chuck_IO::FLOAT32 )
3444 // 1.5.0.0 (ge) | fixed from size to sizeof3613 {
3445 fwrite(buf, 1, sizeof(val), m_cfd);3614 float v = (float)val;
3615 char * buf = (char *)&v;
3616 for(int i = 0; i < sizeof(v); i++)
3617 m_writeBuffer.put(buf[i]);
3618 }
3619 else if( flags & Chuck_IO::FLOAT64 )
3620 {
3621 double v = (double)val;
3622 char * buf = (char *)&v;
3623 for(int i = 0; i < sizeof(v); i++)
3624 m_writeBuffer.put(buf[i]);
3625 }
3626 else
3627 {
3628 // error message
3629 EM_log(CK_LOG_WARNING, "(Serial.write): invalid or unsupported size flag");
3630 }
3446 }3631 }
3447 }3632 }
3448}3633}
src/core/chuck_io.h+9−2
@@ -72,7 +72,10 @@ t_CKBOOL init_class_serialio( Chuck_Env * env ); · 71 unmodified lines
72//-----------------------------------------------------------------------------72//-----------------------------------------------------------------------------
73// io API73// io API
74//-----------------------------------------------------------------------------74//-----------------------------------------------------------------------------
75CK_DLL_MFUN( io_dummy );75CK_DLL_MFUN( io_dummy_int );
76CK_DLL_MFUN( io_dummy_float );
77CK_DLL_MFUN( io_dummy_string );
78CK_DLL_MFUN( io_dummy_void );
76CK_DLL_SFUN( io_newline );79CK_DLL_SFUN( io_newline );
77CK_DLL_SFUN( io_openfile );80CK_DLL_SFUN( io_openfile );
78 81
@@ -103,12 +106,14 @@ CK_DLL_MFUN( fileio_readint8 ); · 24 unmodified lines
103CK_DLL_MFUN( fileio_readint16 );106CK_DLL_MFUN( fileio_readint16 );
104CK_DLL_MFUN( fileio_readint32 );107CK_DLL_MFUN( fileio_readint32 );
105CK_DLL_MFUN( fileio_readfloat );108CK_DLL_MFUN( fileio_readfloat );
109CK_DLL_MFUN( fileio_readfloatflags );
106CK_DLL_MFUN( fileio_eof );110CK_DLL_MFUN( fileio_eof );
107CK_DLL_MFUN( fileio_more );111CK_DLL_MFUN( fileio_more );
108CK_DLL_MFUN( fileio_writestring );112CK_DLL_MFUN( fileio_writestring );
109CK_DLL_MFUN( fileio_writeint );113CK_DLL_MFUN( fileio_writeint );
110CK_DLL_MFUN( fileio_writeintflags );114CK_DLL_MFUN( fileio_writeintflags );
111CK_DLL_MFUN( fileio_writefloat );115CK_DLL_MFUN( fileio_writefloat );
116CK_DLL_MFUN( fileio_writefloatflags );
112// #endif // __DISABLE_FILEIO__117// #endif // __DISABLE_FILEIO__
113 118
114 119
@@ -312,15 +317,17 @@ public: · 197 unmodified lines
312 virtual Chuck_String * readLine();317 virtual Chuck_String * readLine();
313 virtual t_CKINT readInt( t_CKINT flags );318 virtual t_CKINT readInt( t_CKINT flags );
314 virtual t_CKFLOAT readFloat();319 virtual t_CKFLOAT readFloat();
320 virtual t_CKFLOAT readFloat( t_CKINT flags );
315 virtual t_CKBOOL readString( std::string & str );321 virtual t_CKBOOL readString( std::string & str );
316 virtual t_CKBOOL eof();322 virtual t_CKBOOL eof();
317 323
318 // writing324 // writing
319 virtual void write( const std::string & val );325 virtual void write( const std::string & val );
320 virtual void write( t_CKINT val );326 virtual void write( t_CKINT val );
321 virtual void write( t_CKINT val, t_CKINT size );327 virtual void write( t_CKINT val, t_CKINT flags );
322 virtual void writeBytes( Chuck_Array4 * arr );328 virtual void writeBytes( Chuck_Array4 * arr );
323 virtual void write( t_CKFLOAT val );329 virtual void write( t_CKFLOAT val );
330 virtual void write( t_CKFLOAT val, t_CKINT flags );
324 331
325 // serial stuff332 // serial stuff
326 virtual t_CKBOOL setBaudRate( t_CKUINT rate );333 virtual t_CKBOOL setBaudRate( t_CKUINT rate );
src/core/chuck_oo.cpp+263−71
@@ -55,18 +55,28 @@ using namespace std; · 54 unmodified lines
55t_CKBOOL Chuck_VM_Object::our_locks_in_effect = TRUE;55t_CKBOOL Chuck_VM_Object::our_locks_in_effect = TRUE;
56 56
57// constants57// constants
58const t_CKINT Chuck_IO::TYPE_ASCII = 0x1;58const t_CKINT Chuck_IO::TYPE_ASCII = 0x1;
59const t_CKINT Chuck_IO::TYPE_BINARY = 0x2;59const t_CKINT Chuck_IO::TYPE_BINARY = 0x2;
60const t_CKINT Chuck_IO::INT8 = 0x10;60const t_CKINT Chuck_IO::FLOAT32 = 0x10;
61const t_CKINT Chuck_IO::INT16 = 0x20;61const t_CKINT Chuck_IO::FLOAT64 = 0x20;
62const t_CKINT Chuck_IO::INT24 = 0x40;62const t_CKINT Chuck_IO::INT8 = 0x100;
63const t_CKINT Chuck_IO::INT32 = 0x80;63const t_CKINT Chuck_IO::INT16 = 0x200;
64const t_CKINT Chuck_IO::INT64 = 0x100;64const t_CKINT Chuck_IO::INT24 = 0x400;
65const t_CKINT Chuck_IO::FLOAT32 = 0x200;65const t_CKINT Chuck_IO::INT32 = 0x800;
66const t_CKINT Chuck_IO::FLOAT64 = 0x400;66const t_CKINT Chuck_IO::INT64 = 0x1000;
67const t_CKINT Chuck_IO::FLAG_READ_WRITE = 0x100;67const t_CKINT Chuck_IO::SINT8 = 0x2000;
68const t_CKINT Chuck_IO::FLAG_READONLY = 0x200;68const t_CKINT Chuck_IO::SINT16 = 0x4000;
69const t_CKINT Chuck_IO::FLAG_WRITEONLY = 0x400;69const t_CKINT Chuck_IO::SINT24 = 0x8000;
70const t_CKINT Chuck_IO::SINT32 = 0x10000;
71const t_CKINT Chuck_IO::SINT64 = 0x20000;
72const t_CKINT Chuck_IO::UINT8 = 0x40000;
73const t_CKINT Chuck_IO::UINT16 = 0x80000;
74const t_CKINT Chuck_IO::UINT24 = 0x100000;
75const t_CKINT Chuck_IO::UINT32 = 0x200000;
76const t_CKINT Chuck_IO::UINT64 = 0x400000;
77const t_CKINT Chuck_IO::FLAG_READONLY = 0x100;
78const t_CKINT Chuck_IO::FLAG_WRITEONLY = 0x200;
79const t_CKINT Chuck_IO::FLAG_READ_WRITE = 0x400;
70const t_CKINT Chuck_IO::FLAG_APPEND = 0x800;80const t_CKINT Chuck_IO::FLAG_APPEND = 0x800;
71 81
72#ifndef __DISABLE_THREADS__82#ifndef __DISABLE_THREADS__
@@ -3470,36 +3480,54 @@ t_CKINT Chuck_IO_File::readInt( t_CKINT flags ) · 3397 unmodified lines
3470 else if( m_flags & TYPE_BINARY )3480 else if( m_flags & TYPE_BINARY )
3471 {3481 {
3472 // binary3482 // binary
3473 if( flags & Chuck_IO::INT32 )3483 if( flags & Chuck_IO::INT8 || flags & Chuck_IO::UINT8 ) // 1.5.0.1 (ge) added UINT
3474 {3484 {
3475 // 32-bit3485 // unsigned 8-bit
3476 t_CKINT i;3486 uint8_t i; // 1.5.0.1 (ge) changed to int8_t from unsigned char
3487 m_io.read( (char *)&i, 1 );
3488 if( m_io.gcount() != 1 )
3489 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );
3490 else if( m_io.fail() )
3491 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );
3492 return (t_CKINT)i;
3493 }
3494 else if( flags & Chuck_IO::INT16 || flags & Chuck_IO::UINT16 ) // 1.5.0.1 (ge) added UINT
3495 {
3496 // unsigned 16-bit
3497 uint16_t i; // 1.5.0.1 (ge) changed to uint16_t from t_CKINT
3498 m_io.read( (char *)&i, 2 );
3499 if( m_io.gcount() != 2 )
3500 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );
3501 else if (m_io.fail())
3502 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );
3503 return (t_CKINT)i;
3504 }
3505 else if( flags & Chuck_IO::INT32 || flags & Chuck_IO::UINT32 ) // 1.5.0.1 (ge) added UINT
3506 {
3507 // unsigned 32-bit
3508 uint32_t i; // 1.5.0.1 (ge) changed to uint32_t from t_CKINT
3477 m_io.read( (char *)&i, 4 );3509 m_io.read( (char *)&i, 4 );
3478 if (m_io.gcount() != 4)3510 if (m_io.gcount() != 4)
3479 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );3511 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );
3480 else if (m_io.fail())3512 else if (m_io.fail())
3481 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );3513 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );
3482 return i;3514 return (t_CKINT)i;
3483 }3515 }
3484 else if( flags & Chuck_IO::INT16 )3516 else if( flags & Chuck_IO::INT64 || flags & Chuck_IO::UINT64 ) // 1.5.0.1 (ge) added 64-bit
3485 {3517 {
3486 // 16-bit3518 // unsigned 64-bit
3487 // int16_t i;3519 uint64_t i; // 1.5.0.1 (ge) added
3488 // issue: 64-bit3520 m_io.read( (char *)&i, 8 );
3489 short i;3521 if (m_io.gcount() != 8)
3490 m_io.read( (char *)&i, 2 );
3491 if( m_io.gcount() != 2 )
3492 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );3522 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );
3493 else if (m_io.fail())3523 else if (m_io.fail())
3494 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );3524 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );
3495 return (t_CKINT) i;3525 return (t_CKINT)i; // TODO: handle signed vs unsigned
3496 }3526 }
3497 else if( flags & Chuck_IO::INT8 )3527 else if( flags & Chuck_IO::SINT8 ) // 1.5.0.1 (ge) added SINT
3498 {3528 {
3499 // 8-bit3529 // signed 8-bit
3500 // int8_t i;3530 int8_t i;
3501 // issue: 64-bit
3502 unsigned char i;
3503 m_io.read( (char *)&i, 1 );3531 m_io.read( (char *)&i, 1 );
3504 if( m_io.gcount() != 1 )3532 if( m_io.gcount() != 1 )
3505 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );3533 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );
@@ -3507,9 +3535,42 @@ t_CKINT Chuck_IO_File::readInt( t_CKINT flags ) · 1 unmodified line
3507 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );3535 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );
3508 return (t_CKINT)i;3536 return (t_CKINT)i;
3509 }3537 }
3538 else if( flags & Chuck_IO::SINT16 ) // 1.5.0.1 (ge) added SINT
3539 {
3540 // signed 16-bit
3541 int16_t i;
3542 m_io.read( (char *)&i, 2 );
3543 if( m_io.gcount() != 2 )
3544 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );
3545 else if (m_io.fail())
3546 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );
3547 return (t_CKINT)i;
3548 }
3549 else if( flags & Chuck_IO::SINT32 ) // 1.5.0.1 (ge) added SINT
3550 {
3551 // signed 32-bit
3552 int32_t i;
3553 m_io.read( (char *)&i, 4 );
3554 if (m_io.gcount() != 4)
3555 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );
3556 else if (m_io.fail())
3557 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );
3558 return (t_CKINT)i;
3559 }
3560 else if( flags & Chuck_IO::SINT64 ) // 1.5.0.1 (ge) added SINT
3561 {
3562 // signed 64-bit
3563 int64_t i;
3564 m_io.read( (char *)&i, 4 );
3565 if (m_io.gcount() != 8)
3566 EM_error3( "[chuck](via FileIO): cannot readInt: not enough bytes left" );
3567 else if (m_io.fail())
3568 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );
3569 return (t_CKINT)i;
3570 }
3510 else3571 else
3511 {3572 {
3512 EM_error3( "[chuck](via FileIO): readInt error: invalid int size flag" );3573 EM_error3( "[chuck](via FileIO): readInt error: invalid/unsupported int size flag" );
3513 return 0;3574 return 0;
3514 }3575 }
3515 }3576 }
@@ -3525,33 +3586,43 @@ t_CKINT Chuck_IO_File::readInt( t_CKINT flags ) · 9 unmodified lines
3525 3586
3526//-----------------------------------------------------------------------------3587//-----------------------------------------------------------------------------
3527// name: readFloat()3588// name: readFloat()
3528// desc: read next as (ascii) floating point value3589// desc: read next as floating point value; could be ASCII or BINARY
3529//-----------------------------------------------------------------------------3590//-----------------------------------------------------------------------------
3530t_CKFLOAT Chuck_IO_File::readFloat()3591t_CKFLOAT Chuck_IO_File::readFloat()
3592{
3593 return this->readFloat( Chuck_IO::FLOAT32 );
3594}
3595
3596
3597
3598
3599//-----------------------------------------------------------------------------
3600// name: readFloat()
3601// desc: read next as floating point value; could be ASCII or BINARY
3602//-----------------------------------------------------------------------------
3603t_CKFLOAT Chuck_IO_File::readFloat( t_CKINT flags )
3531{3604{
3532 // sanity3605 // sanity
3533 if (!(m_io.is_open())) {3606 if( !(m_io.is_open()) ) {
3534 EM_error3( "[chuck](via FileIO): cannot readFloat: no file open" );3607 EM_error3( "[chuck](via FileIO): cannot readFloat: no file open" );
3535 return 0;3608 return 0;
3536 }3609 }
3537 3610 if( m_io.eof() ) {
3538 if (m_io.eof()) {
3539 EM_error3( "[chuck](via FileIO): cannot readFloat: EOF reached" );3611 EM_error3( "[chuck](via FileIO): cannot readFloat: EOF reached" );
3540 return 0;3612 return 0;
3541 }3613 }
3542 3614 if( m_io.fail() ) {
3543 if (m_io.fail()) {
3544 EM_error3( "[chuck](via FileIO): cannot readFloat: I/O stream failed" );3615 EM_error3( "[chuck](via FileIO): cannot readFloat: I/O stream failed" );
3545 return 0;3616 return 0;
3546 }3617 }
3547 3618 if( m_dir ) {
3548 if ( m_dir )
3549 {
3550 EM_error3( "[chuck](via FileIO): cannot read a directory" );3619 EM_error3( "[chuck](via FileIO): cannot read a directory" );
3551 return 0;3620 return 0;
3552 }3621 }
3553 3622
3554 if (m_flags & TYPE_ASCII) {3623 // check mode
3624 if( m_flags & TYPE_ASCII )
3625 {
3555 // ASCII3626 // ASCII
3556 t_CKFLOAT val = 0;3627 t_CKFLOAT val = 0;
3557 m_io >> val;3628 m_io >> val;
@@ -3559,17 +3630,38 @@ t_CKFLOAT Chuck_IO_File::readFloat() · 1 unmodified line
3559 // EM_error3( "[chuck](via FileIO): cannot readFloat: I/O stream failed" );3630 // EM_error3( "[chuck](via FileIO): cannot readFloat: I/O stream failed" );
3560 return val;3631 return val;
3561 3632
3562 } else if (m_flags & TYPE_BINARY) {3633 }
3563 // binary3634 else if( m_flags & TYPE_BINARY )
3564 t_CKFLOAT i;3635 {
3565 m_io.read( (char *)&i, sizeof(t_CKFLOAT) );3636 // 1.5.0.1
3566 if (m_io.gcount() != sizeof(t_CKFLOAT) )3637 if( flags & Chuck_IO::FLOAT32 )
3567 EM_error3( "[chuck](via FileIO): cannot readFloat: not enough bytes left" );3638 {
3568 else if (m_io.fail())3639 float i;
3569 EM_error3( "[chuck](via FileIO): cannot readInt: I/O stream failed" );3640 m_io.read( (char *)&i, sizeof(float) );
3570 return i;3641 if (m_io.gcount() != sizeof(float) )
3571 3642 EM_error3( "[chuck](via FileIO): cannot readFloat: not enough bytes left" );
3572 } else {3643 else if (m_io.fail())
3644 EM_error3( "[chuck](via FileIO): cannot readFloat: I/O stream failed" );
3645 return (t_CKFLOAT)i;
3646 }
3647 else if( flags & Chuck_IO::FLOAT64 )
3648 {
3649 double i;
3650 m_io.read( (char *)&i, sizeof(double) );
3651 if (m_io.gcount() != sizeof(double) )
3652 EM_error3( "[chuck](via FileIO): cannot readFloat: not enough bytes left" );
3653 else if (m_io.fail())
3654 EM_error3( "[chuck](via FileIO): cannot readFloat: I/O stream failed" );
3655 return (t_CKFLOAT)i;
3656 }
3657 else
3658 {
3659 EM_error3( "[chuck](via FileIO): readFloat error: invalid/unsupported datatype size flag" );
3660 return 0;
3661 }
3662 }
3663 else
3664 {
3573 EM_error3( "[chuck](via FileIO): readFloat error: invalid ASCII/binary flag" );3665 EM_error3( "[chuck](via FileIO): readFloat error: invalid ASCII/binary flag" );
3574 return 0;3666 return 0;
3575 }3667 }
@@ -3794,14 +3886,64 @@ void Chuck_IO_File::write( t_CKINT val, t_CKINT flags ) · 218 unmodified lines
3794 return;3886 return;
3795 }3887 }
3796 3888
3797 if (m_flags & TYPE_ASCII) {3889 // check file mode
3890 if( m_flags & TYPE_ASCII ) // ASCII mode
3891 {
3892 // insert into file stream
3798 m_io << val;3893 m_io << val;
3799 } else if (m_flags & TYPE_BINARY) {3894 }
3800 int nBytes = 4;3895 else if( m_flags & TYPE_BINARY ) // BINARY mode
3801 if(flags & INT8) nBytes = 1;3896 {
3802 else if(flags & INT16) nBytes = 2;3897 // check datatype size flags
3803 else if(flags & INT32) nBytes = 4;3898 // 1.5.0.1 (ge) modified to new signed/unsigned handling
3804 m_io.write( (char *)&val, nBytes );3899 if( flags & Chuck_IO::INT8 || flags & Chuck_IO::UINT8 )
3900 {
3901 // unsigned 8-bit
3902 uint8_t v = val;
3903 m_io.write( (char *)&v, 1 );
3904 }
3905 else if( flags & Chuck_IO::INT16 || flags & Chuck_IO::UINT16 )
3906 {
3907 // unsigned 16-bit
3908 uint16_t v = val;
3909 m_io.write( (char *)&v, 2 );
3910 }
3911 else if( flags & Chuck_IO::INT32 || flags & Chuck_IO::UINT32 )
3912 {
3913 // unsigned 32-bit
3914 uint32_t v = val;
3915 m_io.write( (char *)&v, 4 );
3916 }
3917 else if( flags & Chuck_IO::INT64 || flags & Chuck_IO::UINT64 )
3918 {
3919 // unsigned 64-bit
3920 uint64_t v = val;
3921 m_io.write( (char *)&v, 8 );
3922 }
3923 else if( flags & Chuck_IO::SINT8 )
3924 {
3925 // signed 8-bit
3926 int8_t v = val;
3927 m_io.write( (char *)&v, 1 );
3928 }
3929 else if( flags & Chuck_IO::SINT16 )
3930 {
3931 // signed 16-bit
3932 int16_t v = val;
3933 m_io.write( (char *)&v, 2 );
3934 }
3935 else if( flags & Chuck_IO::SINT32 )
3936 {
3937 // signed 32-bit
3938 int32_t v = val;
3939 m_io.write( (char *)&v, 4 );
3940 }
3941 else if( flags & Chuck_IO::SINT64 )
3942 {
3943 // signed 32-bit
3944 int64_t v = val;
3945 m_io.write( (char *)&v, 8 );
3946 }
3805 } else {3947 } else {
3806 EM_error3( "[chuck](via FileIO): write error: invalid ASCII/binary flag" );3948 EM_error3( "[chuck](via FileIO): write error: invalid ASCII/binary flag" );
3807 }3949 }
@@ -3816,32 +3958,64 @@ void Chuck_IO_File::write( t_CKINT val, t_CKINT flags ) · 8 unmodified lines
3816 3958
3817//-----------------------------------------------------------------------------3959//-----------------------------------------------------------------------------
3818// name: write( t_CKFLOAT val )3960// name: write( t_CKFLOAT val )
3819// desc: ...3961// desc: write a floating point value
3820//-----------------------------------------------------------------------------3962//-----------------------------------------------------------------------------
3821void Chuck_IO_File::write( t_CKFLOAT val )3963void Chuck_IO_File::write( t_CKFLOAT val )
3964{
3965 this->write( val, Chuck_IO::FLOAT32 );
3966}
3967
3968
3969
3970
3971//-----------------------------------------------------------------------------
3972// name: write( t_CKFLOAT val, t_CKINT flags )
3973// desc: write a floating point value; binary mode will heed flags for size
3974//-----------------------------------------------------------------------------
3975void Chuck_IO_File::write( t_CKFLOAT val, t_CKINT flags )
3822{3976{
3823 // sanity3977 // sanity
3824 if (!(m_io.is_open())) {3978 if( !(m_io.is_open()) ) {
3825 EM_error3( "[chuck](via FileIO): cannot write: no file open" );3979 EM_error3( "[chuck](via FileIO): cannot write: no file open" );
3826 return;3980 return;
3827 }3981 }
3828 3982 if( m_io.fail() ) {
3829 if (m_io.fail()) {
3830 EM_error3( "[chuck](via FileIO): cannot write: I/O stream failed" );3983 EM_error3( "[chuck](via FileIO): cannot write: I/O stream failed" );
3831 return;3984 return;
3832 }3985 }
3833 3986 if( m_dir ) {
3834 if ( m_dir )
3835 {
3836 EM_error3( "[chuck](via FileIO): cannot write to a directory" );3987 EM_error3( "[chuck](via FileIO): cannot write to a directory" );
3837 return;3988 return;
3838 }3989 }
3839 3990
3840 if (m_flags & TYPE_ASCII) {3991 // check ASCII or BINARY
3992 if( m_flags & TYPE_ASCII )
3993 {
3994 // insert into stream
3841 m_io << val;3995 m_io << val;
3842 } else if (m_flags & TYPE_BINARY) {3996 }
3843 m_io.write( (char *)&val, sizeof(t_CKFLOAT) );3997 else if( m_flags & TYPE_BINARY )
3844 } else {3998 {
3999 // 1.5.0.1 (ge) add distinction between different float sizes
4000 if( flags & Chuck_IO::FLOAT32 )
4001 {
4002 // 32-bit
4003 float v = (float)val;
4004 m_io.write( (char *)&v, 4 );
4005 }
4006 else if( flags & Chuck_IO::FLOAT64 )
4007 {
4008 // 64-bit
4009 double v = (double)val;
4010 m_io.write( (char *)&v, 8 );
4011 }
4012 else
4013 {
4014 EM_error3( "[chuck](via FileIO): writeFloat error: invalid/unsupport datatype size flag" );
4015 }
4016 }
4017 else
4018 {
3845 EM_error3( "[chuck](via FileIO): write error: invalid ASCII/binary flag" );4019 EM_error3( "[chuck](via FileIO): write error: invalid ASCII/binary flag" );
3846 }4020 }
3847 4021
@@ -3881,7 +4055,7 @@ THREAD_RETURN ( THREAD_TYPE Chuck_IO_File::writeInt_thread ) ( void *data ) · 33 unmodified lines
3881THREAD_RETURN ( THREAD_TYPE Chuck_IO_File::writeFloat_thread ) ( void *data )4055THREAD_RETURN ( THREAD_TYPE Chuck_IO_File::writeFloat_thread ) ( void *data )
3882{4056{
3883 async_args *args = (async_args *)data;4057 async_args *args = (async_args *)data;
3884 args->fileio_obj->write ( args->floatArg );4058 args->fileio_obj->write( args->floatArg, args->intArg );
3885 args->fileio_obj->m_asyncEvent->broadcast_local(); // wake up4059 args->fileio_obj->m_asyncEvent->broadcast_local(); // wake up
3886 args->fileio_obj->m_asyncEvent->broadcast_global();4060 args->fileio_obj->m_asyncEvent->broadcast_global();
3887 delete args;4061 delete args;
@@ -3960,7 +4134,10 @@ t_CKINT Chuck_IO_Chout::readInt( t_CKINT flags ) · 72 unmodified lines
3960{ return 0; }4134{ return 0; }
3961 4135
3962t_CKFLOAT Chuck_IO_Chout::readFloat()4136t_CKFLOAT Chuck_IO_Chout::readFloat()
3963{ return 0.0f; }4137{ return 0; }
4138
4139t_CKFLOAT Chuck_IO_Chout::readFloat( t_CKINT flags )
4140{ return 0; }
3964 4141
3965t_CKBOOL Chuck_IO_Chout::readString( std::string & str )4142t_CKBOOL Chuck_IO_Chout::readString( std::string & str )
3966{4143{
@@ -3993,6 +4170,11 @@ void Chuck_IO_Chout::write( t_CKFLOAT val ) · 26 unmodified lines
3993 m_buffer << val;4170 m_buffer << val;
3994}4171}
3995 4172
4173void Chuck_IO_Chout::write( t_CKFLOAT val, t_CKINT flags )
4174{
4175 // ignore flags for chout
4176 m_buffer << val;
4177}
3996 4178
3997 4179
3998 4180
@@ -4062,7 +4244,10 @@ t_CKINT Chuck_IO_Cherr::readInt( t_CKINT flags ) · 63 unmodified lines
4062{ return 0; }4244{ return 0; }
4063 4245
4064t_CKFLOAT Chuck_IO_Cherr::readFloat()4246t_CKFLOAT Chuck_IO_Cherr::readFloat()
4065{ return 0.0f; }4247{ return 0; }
4248
4249t_CKFLOAT Chuck_IO_Cherr::readFloat( t_CKINT flags )
4250{ return 0; }
4066 4251
4067t_CKBOOL Chuck_IO_Cherr::readString( std::string & str )4252t_CKBOOL Chuck_IO_Cherr::readString( std::string & str )
4068{4253{
@@ -4097,3 +4282,10 @@ void Chuck_IO_Cherr::write( t_CKFLOAT val ) · 28 unmodified lines
4097 m_buffer << val;4282 m_buffer << val;
4098 flush(); // always flush for cerr | 1.5.0.0 (ge) added4283 flush(); // always flush for cerr | 1.5.0.0 (ge) added
4099}4284}
4285
4286void Chuck_IO_Cherr::write( t_CKFLOAT val, t_CKINT flags )
4287{
4288 // ignore flags for cherr
4289 m_buffer << val;
4290 flush(); // always flush for cerr | 1.5.0.0 (ge) added
4291}
src/core/chuck_oo.h+22−2
@@ -617,6 +617,7 @@ public: · 616 unmodified lines
617 virtual Chuck_String * readLine() = 0;617 virtual Chuck_String * readLine() = 0;
618 virtual t_CKINT readInt( t_CKINT flags ) = 0;618 virtual t_CKINT readInt( t_CKINT flags ) = 0;
619 virtual t_CKFLOAT readFloat() = 0;619 virtual t_CKFLOAT readFloat() = 0;
620 virtual t_CKFLOAT readFloat( t_CKINT flags ) = 0;
620 virtual t_CKBOOL readString( std::string & str ) = 0;621 virtual t_CKBOOL readString( std::string & str ) = 0;
621 virtual t_CKBOOL eof() = 0;622 virtual t_CKBOOL eof() = 0;
622 623
@@ -625,6 +626,7 @@ public: · 2 unmodified lines
625 virtual void write( t_CKINT val ) = 0;626 virtual void write( t_CKINT val ) = 0;
626 virtual void write( t_CKINT val, t_CKINT flags ) = 0;627 virtual void write( t_CKINT val, t_CKINT flags ) = 0;
627 virtual void write( t_CKFLOAT val ) = 0;628 virtual void write( t_CKFLOAT val ) = 0;
629 virtual void write( t_CKFLOAT val, t_CKINT flags ) = 0;
628 630
629public:631public:
630 // type | moved to IO in 1.5.0.0 (ge)632 // type | moved to IO in 1.5.0.0 (ge)
@@ -636,8 +638,20 @@ public: · 5 unmodified lines
636 static const t_CKINT INT24; // 1.5.0.1 (ge) added638 static const t_CKINT INT24; // 1.5.0.1 (ge) added
637 static const t_CKINT INT32;639 static const t_CKINT INT32;
638 static const t_CKINT INT64; // 1.5.0.1 (ge) added640 static const t_CKINT INT64; // 1.5.0.1 (ge) added
639 static const t_CKINT FLOAT32; // 1.5.0.1 (ge) added641 // 1.5.0.1 (ge) added SINT and UINT type flags
640 static const t_CKINT FLOAT64; // 1.5.0.1 (ge) added642 static const t_CKINT SINT8;
643 static const t_CKINT SINT16;
644 static const t_CKINT SINT24;
645 static const t_CKINT SINT32;
646 static const t_CKINT SINT64;
647 static const t_CKINT UINT8;
648 static const t_CKINT UINT16;
649 static const t_CKINT UINT24;
650 static const t_CKINT UINT32;
651 static const t_CKINT UINT64;
652 // 1.5.0.1 (ge) added FLOAT type flags
653 static const t_CKINT FLOAT32;
654 static const t_CKINT FLOAT64;
641 // flags | moved to IO in 1.5.0.0 (ge)655 // flags | moved to IO in 1.5.0.0 (ge)
642 static const t_CKINT FLAG_READ_WRITE;656 static const t_CKINT FLAG_READ_WRITE;
643 static const t_CKINT FLAG_READONLY;657 static const t_CKINT FLAG_READONLY;
@@ -698,6 +712,7 @@ public: · 54 unmodified lines
698 virtual Chuck_String * readLine();712 virtual Chuck_String * readLine();
699 virtual t_CKINT readInt( t_CKINT flags );713 virtual t_CKINT readInt( t_CKINT flags );
700 virtual t_CKFLOAT readFloat();714 virtual t_CKFLOAT readFloat();
715 virtual t_CKFLOAT readFloat( t_CKINT flags );
701 virtual t_CKBOOL readString( std::string & str );716 virtual t_CKBOOL readString( std::string & str );
702 virtual t_CKBOOL eof();717 virtual t_CKBOOL eof();
703 718
@@ -714,6 +729,7 @@ public: · 10 unmodified lines
714 virtual void write( t_CKINT val );729 virtual void write( t_CKINT val );
715 virtual void write( t_CKINT val, t_CKINT flags );730 virtual void write( t_CKINT val, t_CKINT flags );
716 virtual void write( t_CKFLOAT val );731 virtual void write( t_CKFLOAT val );
732 virtual void write( t_CKFLOAT val, t_CKINT flags );
717 733
718 #ifndef __DISABLE_THREADS__734 #ifndef __DISABLE_THREADS__
719 // writing -- async735 // writing -- async
@@ -765,6 +781,7 @@ public: · 45 unmodified lines
765 virtual Chuck_String * readLine();781 virtual Chuck_String * readLine();
766 virtual t_CKINT readInt( t_CKINT flags );782 virtual t_CKINT readInt( t_CKINT flags );
767 virtual t_CKFLOAT readFloat();783 virtual t_CKFLOAT readFloat();
784 virtual t_CKFLOAT readFloat( t_CKINT flags );
768 virtual t_CKBOOL readString( std::string & str );785 virtual t_CKBOOL readString( std::string & str );
769 virtual t_CKBOOL eof();786 virtual t_CKBOOL eof();
770 787
@@ -773,6 +790,7 @@ public: · 2 unmodified lines
773 virtual void write( t_CKINT val );790 virtual void write( t_CKINT val );
774 virtual void write( t_CKINT val, t_CKINT flags );791 virtual void write( t_CKINT val, t_CKINT flags );
775 virtual void write( t_CKFLOAT val );792 virtual void write( t_CKFLOAT val );
793 virtual void write( t_CKFLOAT val, t_CKINT flags );
776 794
777public: // REFACTOR-2017795public: // REFACTOR-2017
778 // set callback796 // set callback
@@ -810,6 +828,7 @@ public: · 31 unmodified lines
810 virtual Chuck_String * readLine();828 virtual Chuck_String * readLine();
811 virtual t_CKINT readInt( t_CKINT flags );829 virtual t_CKINT readInt( t_CKINT flags );
812 virtual t_CKFLOAT readFloat();830 virtual t_CKFLOAT readFloat();
831 virtual t_CKFLOAT readFloat( t_CKINT flags );
813 virtual t_CKBOOL readString( std::string & str );832 virtual t_CKBOOL readString( std::string & str );
814 virtual t_CKBOOL eof();833 virtual t_CKBOOL eof();
815 834
@@ -818,6 +837,7 @@ public: · 2 unmodified lines
818 virtual void write( t_CKINT val );837 virtual void write( t_CKINT val );
819 virtual void write( t_CKINT val, t_CKINT flags );838 virtual void write( t_CKINT val, t_CKINT flags );
820 virtual void write( t_CKFLOAT val );839 virtual void write( t_CKFLOAT val );
840 virtual void write( t_CKFLOAT val, t_CKINT flags );
821 841
822public:842public:
823 // set callback | REFACTOR-2017843 // set callback | REFACTOR-2017

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t