1 /******************************************************************************
5 * $Date: 2007/03/26 03:20:31 $
8 * $Log: tape_block.cpp,v $
9 * Revision 2.1 2007/03/26 03:20:31 hachti
10 * *** empty log message ***
12 * Revision 2.0 2007-03-26 01:00:40 hachti
13 * *** empty log message ***
16 ******************************************************************************/
26 #include "tape_block.hh"
28 #include "silent_code.hh"
29 #include "hw_constants.hh"
31 #include "eot_block.hh"
32 #include "data_block.hh"
33 #include "broken_block.hh"
34 #include "data_block_0.hh"
35 #include "data_block_0_0.hh"
36 #include "data_block_0_1.hh"
37 #include "data_block_0_2.hh"
38 #include "data_block_0_3.hh"
39 #include "data_block_0_4.hh"
40 #include "data_block_0_10.hh"
41 #include "data_block_0_14.hh"
42 #include "data_block_0_24.hh"
43 #include "data_block_0_44.hh"
44 #include "data_block_0_30.hh"
45 #include "data_block_0_54.hh"
46 #include "data_block_0_60.hh"
47 #include "data_block_0_50.hh"
48 #include "data_block_0_64.hh"
49 #include "data_block_1.hh"
50 #include "data_block_2.hh"
51 #include "data_block_3.hh"
52 #include "data_block_4.hh"
53 #include "data_block_5.hh"
54 #include "data_block_6.hh"
55 #include "data_block_7.hh"
59 /***************************************************************/
63 tape_block::~tape_block(){
68 /***************************************************************/
70 *\brief Copy constructor.
72 tape_block::tape_block(tape_block
& org
){
76 /***************************************************************/
78 *\brief Assignment operator.
80 void tape_block::operator=(tape_block
&org
){
81 block_type
=org
.block_type
;
82 discarded_bytes
=org
.discarded_bytes
;
84 raw_size
=org
.raw_size
;
86 word_size
=org
.word_size
;
88 raw_data
=(unsigned char *)malloc(raw_size
);
89 memcpy(raw_data
,org
.raw_data
,raw_size
);
92 word_data
=(unsigned short *)malloc(word_size
*sizeof(unsigned short));
93 memcpy(word_data
,org
.word_data
,word_size
*sizeof(unsigned short));
97 /***************************************************************/
99 *\brief Determine the block's type
101 * This routine returns the block's type.\\
102 *\retval TBT_DATA if it's a data block
103 *\retval TBT_EOT if it's an end of tape mark
105 *\note This function is virtual. That means that if the tape block in
106 * question is of the subtype data_block which overwrites this method,
107 * it will return the block type contained in the upper 4 bits of the
108 * first data word! Try to avoid testing for TBT_DATA. \n
109 * Blocks generated by gen_from_fd should never have TBT_DATA.
111 int tape_block::get_type(){
115 /***************************************************************/
117 *\brief Determine the block's subtype
119 * Some data block types have a subtype.
120 *\note This is a virtual method and to be used in derived classes.
123 int tape_block::get_subtype(){
127 /***************************************************************/
129 *\brief Get a cleartext description of the block.
130 *\return ldc style descriptive line for the block
132 vector
<string
> tape_block:: get_description(){
133 vector
<string
> result
;
134 result
.insert(result
.end(),
135 "***** "+get_typestring()+"Untyped tape block");
139 /***************************************************************/
141 *\brief Get size of the internal raw data buffer
142 *\return The size of the internal raw data buffer
144 int tape_block::get_raw_size(){
148 /***************************************************************/
150 *\brief Get amount of bytes discarded before beginning
152 *\return Length of unusable tape before block start delimiter.
154 int tape_block::get_discarded_bytes(){
155 return discarded_bytes
;
158 /***************************************************************/
160 *\brief Access internal raw data buffer
162 * The raw data buffer contains all block data except the
163 * block start and end delimiters.
164 *\return Pointer to internal raw data buffer of the block
166 unsigned char * tape_block::get_raw_data(){
170 /***************************************************************/
172 *\brief Dump contents of the block to a file descriptor.
174 *\param fd A writable file descriptor.
175 *\return Always zero.
176 *\throw io_error_exception A write error occured.
178 int tape_block::dump_to_fd(int fd
){
179 int to_write
=raw_size
;
180 unsigned char * dump_ptr
=raw_data
;
183 written
=write(fd
,dump_ptr
,to_write
);
184 if (written
< 0) throw io_error_exception();
191 /***************************************************************/
193 *\brief Determine if the block marks the end of an object
194 *\retval true The block marks the end of an object.
195 *\retval false The block does not mark the end of an object.
196 *\note This is only a virtual method returning always false.
197 * Classes which can be the legal last block of an object
198 * will overwrite this method so that it returns true.
200 bool tape_block::is_endblock(){
204 /***************************************************************/
206 *\brief Get exported symbols.
207 *\return A vector containing any symbols exported in this block.
208 *\note This is only a virtual method returning always an empty
209 * vector. Classes describing appropriate data blocks
210 * will override this method.
212 vector
<string
> tape_block::get_exported_symbols(){
213 vector
<string
> result
;
217 /***************************************************************/
219 *\brief Get called symbols.
220 *\return A vector containing any symbols called in this block.
221 *\note This is only a virtual method returning always an empty
222 * vector. Classes describing appropriate data blocks
223 * will override this method.
225 vector
<string
> tape_block::get_called_symbols(){
226 vector
<string
> result
;
230 /***************************************************************/
232 *\brief Determine if the block has a known type.
233 *\return true if type and subtype are known.
234 *\return false if the block type is not one of the valid end
235 * nodes of the type tree.
237 bool tape_block::has_known_type(){
238 return m_has_known_type
;
241 /***************************************************************/
243 *\brief Static factory method for tape blocks.
245 * This method creates a tape_block by using the private
246 * constructor with file descriptor support.\n
248 * The factory method tries to determine the block's type and then
249 * looks for appropriate subclasses. If there's an appropriate
250 * subclass fitting the newly-created object, an
251 * object of the subclass will be created and a pointer to this
252 * object will be returned to the caller.\n
253 * This allows for easy use of the object using it's virtual
254 * interface methods or a cast of the pointer to a sub type pointer
255 * according to the type information, and then using the subtype's
256 * methods not already present in tape_block.\n
257 * Objects of the following subclasses are automagically generated:\n
282 *\return Pointer to an instance of tape_block or a subclass.
283 *\param fd A file descriptor where data can be read from.
284 *\param input_start A pointer to a function
285 * called before reading data from fd.
286 *\param input_stop A pointer to a function
287 * called after reading data from fd.
289 *\param start_stop_arg A pointer passed to input_start
290 * and input_stop(). Can be anything.
292 tape_block
* tape_block::gen_from_fd(int fd
,
293 void(*input_start
)(void *),
294 void (*input_stop
)(void *),
295 void * start_stop_arg
)
297 tape_block
* n_tape_block
=0;
298 data_block
* n_data_block
=0;
299 data_block
* n_data_block_x
=0;
300 data_block_0
* n_data_block_0
=0;
301 data_block_0
* n_data_block_0_x
=0;
302 eot_block
* n_eot_block
=0;
303 broken_block
* n_broken_block
=0;
305 //Use the private constructor which reads in the block from a file descriptor
307 n_tape_block
=new tape_block(fd
,input_start
,input_stop
,start_stop_arg
);
310 catch(checksum_error_exception e
){
311 n_broken_block
=new broken_block(*(e
.get_block()));
312 delete e
.get_block();
313 throw checksum_error_exception(n_broken_block
);
316 // Retype to data_block, eot_block - if possible
317 switch(n_tape_block
->get_type()){
318 case tape_block::TBT_DATA
:
319 n_data_block
= new data_block(*n_tape_block
);
321 case tape_block::TBT_EOT
:
322 n_eot_block
=new eot_block(*n_tape_block
);
324 n_eot_block
->m_has_known_type
=true;
326 default: // Unknown block, a bad thing!
331 // Now only data blocks are left
333 switch(n_data_block
->get_type()){
334 case 00: n_data_block_0
=new data_block_0(*n_data_block
); break;
335 case 01: n_data_block_x
=new data_block_1(*n_data_block
); break;
336 case 02: n_data_block_x
=new data_block_2(*n_data_block
); break;
337 case 03: n_data_block_x
=new data_block_3(*n_data_block
); break;
338 case 04: n_data_block_x
=new data_block_4(*n_data_block
); break;
339 case 05: n_data_block_x
=new data_block_5(*n_data_block
); break;
340 case 06: n_data_block_x
=new data_block_6(*n_data_block
); break;
341 case 07: n_data_block_x
=new data_block_7(*n_data_block
); break;
345 if (n_data_block_0
==0){ // So we must have found another one
347 n_data_block_x
->m_has_known_type
=true;
348 return n_data_block_x
;
351 // Here only type 0 left
352 switch(n_data_block_0
->get_subtype()){
353 case 000: n_data_block_0_x
=new data_block_0_0(*n_data_block_0
); break;
354 case 001: n_data_block_0_x
=new data_block_0_1(*n_data_block_0
); break;
355 case 002: n_data_block_0_x
=new data_block_0_2(*n_data_block_0
); break;
356 case 003: n_data_block_0_x
=new data_block_0_3(*n_data_block_0
); break;
357 case 004: n_data_block_0_x
=new data_block_0_4(*n_data_block_0
); break;
358 case 010: n_data_block_0_x
=new data_block_0_10(*n_data_block_0
); break;
359 case 014: n_data_block_0_x
=new data_block_0_14(*n_data_block_0
); break;
360 case 024: n_data_block_0_x
=new data_block_0_24(*n_data_block_0
); break;
361 case 044: n_data_block_0_x
=new data_block_0_44(*n_data_block_0
); break;
362 case 030: n_data_block_0_x
=new data_block_0_30(*n_data_block_0
); break;
363 case 054: n_data_block_0_x
=new data_block_0_54(*n_data_block_0
); break;
364 case 060: n_data_block_0_x
=new data_block_0_60(*n_data_block_0
); break;
365 case 064: n_data_block_0_x
=new data_block_0_64(*n_data_block_0
); break;
366 case 050: n_data_block_0_x
=new data_block_0_50(*n_data_block_0
); break;
368 return n_data_block_0
;
370 delete n_data_block_0
;
371 n_data_block_0_x
->m_has_known_type
=true;
372 return n_data_block_0_x
;
375 /***************************************************************/
377 *\brief Default constructor.
379 tape_block::tape_block(){}
381 /***************************************************************/
383 *\brief get a short type description string.
384 *\return A small string to be used in description methods.
386 * The string is always 19 characters long.\n
387 * An example is "(99-99) ".
389 string
tape_block::get_typestring(){
391 sprintf(buffer
,"(%o-%o) ",get_type(),get_subtype());
393 return string(buffer
);
396 /***************************************************************/
398 *\brief Automatic constructor with file descriptor support
400 * This constructor is used to initialise the block read in the
401 * block's data via a file descriptor.\n
402 * This is done in the following way:
403 * - input_start() is called.
404 * - Data is read from fd. Stops on end of file or end of block
405 * or IO error. On EOF or IO error input_stop() is NOT called.
406 * - If there was no IO error the block's checksum is calculated
408 * - The block's type field is initialised.
409 * - input_stop() is called.
411 *\param fd A file descriptor where the read is taken from
412 *\param input_stop A pointer to a function called at the end of input
413 *\param input_start A pointer to a function called at the beginning
415 *\param start_stop_arg A pointer passed to input_start and input_stop().
417 tape_block::tape_block (int fd
,
418 void(*input_start
)(void *),
419 void (*input_stop
)(void *),
420 void * start_stop_arg
423 unsigned char buffer
;
425 int eot_needed
=EOT_LENGTH
;
426 int eob_needed
=EOB_LENGTH
;
427 int block_complete
=0;
429 block_type
= TBT_BROKEN
;
437 // Get initial portion of memory
438 raw_data
=(unsigned char*)malloc(poolsize
);
440 if (input_start
) input_start (start_stop_arg
);
442 /* Look for block start in input stream */
444 retval
=read(fd
, &buffer
, 1);
445 if (retval
== 0){ // End of file
447 throw eof_legal_exception(discarded_bytes
);
450 if (retval
== -1){ // Error reading from fd
452 throw io_error_exception();
457 /* Look for end ot tape sequence */
460 if (buffer
==EOT_SEQ_1
) eot_needed
--;
461 else eot_needed
=EOT_LENGTH
;
464 if (buffer
==EOT_SEQ_2
) eot_needed
--;
465 else eot_needed
=EOT_LENGTH
;
468 if (buffer
==EOT_SEQ_3
){
469 raw_data
=(unsigned char*)realloc(raw_data
,3);
472 raw_data
[0]=EOT_SEQ_1
;
473 raw_data
[1]=EOT_SEQ_2
;
474 raw_data
[2]=EOT_SEQ_3
;
478 else eot_needed
=EOT_LENGTH
;
481 } while (buffer
!= (unsigned char) BLOCK_START_DELIMITER
);
482 discarded_bytes
--; // Don't want to declare the start delimiter discarded!
483 raw_size
=1; // But we want to account it here!
485 /* Now input the block data */
488 raw_data
[0]=buffer
; // Put the start delimiter in!
491 retval
= read (fd
, &buffer
, 1);
493 if (retval
== 0){ // End of file
494 broken_block
* b_block
=new broken_block(*this);
496 throw eof_illegal_exception(b_block
);
498 if (retval
== -1){ // Error reading from fd
500 throw io_error_exception();
503 /* sort in the new byte */
505 // Need more memory??
506 if (raw_size
>poolsize
){
508 raw_data
=(unsigned char*)realloc(raw_data
,poolsize
);
511 raw_data
[raw_size
-1]=buffer
;
513 /* Look for end ot block sequence */
516 if (buffer
==BLOCK_END_DELIMITER_1
) eob_needed
--;
517 else eob_needed
=EOB_LENGTH
;
520 if (buffer
==BLOCK_END_DELIMITER_2
){
523 else eob_needed
=EOB_LENGTH
;
526 }while (!block_complete
);
528 if (input_stop
) input_stop (start_stop_arg
);
531 /* Now we have the data in. */
533 if (init_words()!=0){
534 broken_block
* b_block
=new broken_block(*this);
537 throw checksum_error_exception(b_block
);
540 if (test_checksum()!=0){
541 broken_block
* b_block
=new broken_block(*this);
544 throw checksum_error_exception(b_block
);
550 /***************************************************************/
552 *\brief Initialize word representation of data.
553 *\retval 0 on success.
556 int tape_block::init_words(){
557 word_size
=(raw_size
-EOB_LENGTH
-1)/3;
558 if (word_size
<MINIMUM_DATA_BLOCK_WORDSIZE
) return 1; // Block too short!
559 word_data
=(unsigned short *)malloc(word_size
*sizeof(unsigned short));
560 for (int pos
=0; pos
<word_size
; pos
++)
561 word_data
[pos
]=combine466(raw_data
+1+3*pos
);
565 /***************************************************************/
567 *\brief Calculate and check checksum.
568 *\retval 0 on success.
571 int tape_block::test_checksum(){
572 unsigned short sum
=0;
573 for (int pos
=0; pos
<word_size
-1;pos
++)
575 if (sum
==word_data
[word_size
-1]) return 0;
579 /***************************************************************/
581 *\brief Standard constructor of exception base class.
583 tape_block::exception::exception(){
586 /***************************************************************/
588 *\brief Standard desctructor.
590 tape_block::exception::~exception(){
593 /***************************************************************/
595 *\brief Get pointer to erroneous tape_block
596 *\return A pointer to a tape_block instance.
597 *\note The user has to take care to free the instance contained
598 * in objects of classes supporting this method.
600 tape_block
* tape_block::exception::get_block(){
601 return m_broken_block
;
604 /***************************************************************/
608 tape_block::checksum_error_exception::
609 checksum_error_exception (tape_block
* broken_block
){
610 this->m_broken_block
=broken_block
;
613 /***************************************************************/
617 tape_block::eof_illegal_exception::
618 eof_illegal_exception (tape_block
* broken_block
){
619 this->m_broken_block
=broken_block
;
622 /***************************************************************/
625 *\param bytes_consumed Amount of bytes read while looking
628 tape_block::eof_legal_exception::
629 eof_legal_exception(int bytes_consumed
){
630 this->m_broken_block
=NULL
;
631 this->bytes_consumed
=bytes_consumed
;
634 /***************************************************************/
636 *\brief Get amount of consumed data before EOF came along.
637 *\return Amount of bytes read from fd while looking for
640 int tape_block::eof_legal_exception::get_consumed(){
641 return bytes_consumed
;
644 /***************************************************************/
648 tape_block::io_error_exception::
649 io_error_exception(){
650 this->m_broken_block
=NULL
;