mirror of
https://github.com/idolpx/libMeatloaf.git
synced 2025-12-06 04:38:49 -05:00
156 lines
5.5 KiB
C++
156 lines
5.5 KiB
C++
// #ifdef BUILD_IEC
|
|
// #include "iec_buffer.h"
|
|
|
|
// oiecstream iecStream;
|
|
|
|
// /********************************************************
|
|
// * oiecbuf
|
|
// *
|
|
// * A buffer for writing IEC data, handles sending EOI
|
|
// ********************************************************/
|
|
|
|
|
|
// /********************************************************
|
|
// * SAVE ops, pipe mode = _S_out, uses get area
|
|
// ********************************************************/
|
|
// size_t oiecstream::receiveBytesViaIEC() {
|
|
// // we are in a SAVE operation here, so we are pulling bytes from C64 to file, by reading from IEC
|
|
// // underflow happened to our get buffer and this function was called, it has to read bytes from IEC
|
|
// // put them in gbuff and setg to point to them
|
|
|
|
// // TODO: implement
|
|
// return 0;
|
|
// }
|
|
|
|
// /********************************************************
|
|
// * LOAD ops, pipe mode = _S_in, uses put area
|
|
// ********************************************************/
|
|
// void oiecstream::flushpbuff() {
|
|
// // a seek was called on our pipe, meaning we want to change the location we are reading from
|
|
// // since there might be some bytes in the buffer from previous read operations,
|
|
// // waiting to be sent, we need to flush them, as they won't be!
|
|
|
|
// setp(data, data+IEC_BUFFER_SIZE); // reset the beginning and ending buffer pointers
|
|
// }
|
|
|
|
// size_t oiecstream::sendBytesViaIEC() {
|
|
// size_t written = 0;
|
|
|
|
// // we are in a LOAD operation here, so we are pusing bytes from file to C64, by writing to IEC
|
|
|
|
// // Serial.printf("buff :");
|
|
// // for(auto i = pbase(); i<pptr(); i++) {
|
|
// // Serial.printf("%c",*i);
|
|
// // }
|
|
// // Debug_printv("\n");
|
|
|
|
// // we're always writing without the last character in buffer just to be able to send this special delay
|
|
// // if this is last character in the file
|
|
|
|
// //Debug_printv("IEC sendBytesViaIEC will try to send %d bytes over IEC", pptr()-pbase());
|
|
|
|
// // pptr = Returns the pointer to the current character (put pointer) in the put area.
|
|
// // pbase = Returns the pointer to the beginning ("base") of the put area.
|
|
// // epptr = Returns the pointer one past the end of the put area.
|
|
// Serial.printf("loading file: buff->IEC:");
|
|
// for(auto b = pbase(); b < pptr()-1; b++) {
|
|
// //Serial.printf("%c",*b);
|
|
// //Serial.printf("%c[%.2X]",*b, *b);
|
|
// bool sendSuccess = m_iec->sendByte(*b);
|
|
// //bool sendSuccess = true;
|
|
// if(sendSuccess && !(IEC.flags bitand ATN_PULLED) ) written++;
|
|
// else if(!sendSuccess) {
|
|
// // JAIME: what should happen here? should the badbit be set when send returns false?
|
|
// setstate(badbit);
|
|
// setp(data+written, data+IEC_BUFFER_SIZE); // set pbase to point to next unwritten char
|
|
// Debug_printv("IEC acknowledged %d bytes, then failed\n", written);
|
|
// return written;
|
|
// }
|
|
// else {
|
|
// // ATN was pulled
|
|
// setp(data+written, data+IEC_BUFFER_SIZE); // set pbase to point to next unwritten char
|
|
// Debug_printv("IEC acknowledged %d bytes, then ATN was pulled\n", written);
|
|
// return written;
|
|
// }
|
|
// }
|
|
|
|
|
|
// // probably more bytes to come, so
|
|
// // here we wrote all buffer chars but the last one.
|
|
// // we will take this last byte, put it at position 0 and set pptr to 1
|
|
// char lastChar = *(pbase()+written);
|
|
// setp(data, data+IEC_BUFFER_SIZE); // reset the beginning and ending buffer pointers
|
|
// pbump(1); // and set pptr to 1 to tell there's 1 byte in our buffer
|
|
// data[0] = lastChar; // let's put it at position 0
|
|
// Debug_printv("---> LAST [%.2X]\n", data[0]);
|
|
// Debug_printv("IEC acknowledged %d bytes\n", written);
|
|
|
|
// return written;
|
|
// }
|
|
|
|
// int oiecstream::overflow(int ch) {
|
|
// if (!is_open())
|
|
// {
|
|
// return EOF;
|
|
// }
|
|
|
|
// Debug_printv("overflow for iec called, size=%d", pptr()-pbase());
|
|
// char* end = pptr();
|
|
// if ( ch != EOF ) {
|
|
// pbump(1);
|
|
// *end ++ = ch;
|
|
// }
|
|
|
|
// size_t written = sendBytesViaIEC();
|
|
|
|
// if ( written == 0 ) {
|
|
// ch = EOF;
|
|
// } else if ( ch == EOF ) {
|
|
// ch = 0;
|
|
// }
|
|
|
|
// return ch;
|
|
// };
|
|
|
|
// int oiecstream::sync() {
|
|
// if(pptr()-pbase() <= 1) {
|
|
// Debug_printv("sync for iec called - nothing more to write");
|
|
// return 0;
|
|
// }
|
|
// else {
|
|
// Debug_printv("sync for iec called - buffer contains %d bytes", pptr()-pbase());
|
|
// auto result = sendBytesViaIEC();
|
|
// return (result != 0) ? 0 : -1;
|
|
// }
|
|
// };
|
|
|
|
|
|
// /********************************************************
|
|
// * oiecstream
|
|
// *
|
|
// * Standard C++ stream for writing to IEC
|
|
// ********************************************************/
|
|
|
|
// void oiecstream::putUtf8(U8Char* codePoint) {
|
|
// //Serial.printf("%c",codePoint->toPetscii());
|
|
// //Debug_printv("oiecstream calling put");
|
|
// auto c = codePoint->toPetscii();
|
|
// put(codePoint->toPetscii());
|
|
// }
|
|
|
|
// // void oiecstream::writeLn(std::string line) {
|
|
// // // line is utf-8, convert to petscii
|
|
|
|
// // std::string converted;
|
|
// // std::stringstream ss(line);
|
|
|
|
// // while(!ss.eof()) {
|
|
// // U8Char codePoint(&ss);
|
|
// // converted+=codePoint.toPetscii();
|
|
// // }
|
|
|
|
// // Debug_printv("UTF8 converted to PETSCII:%s",converted.c_str());
|
|
|
|
// // (*this) << converted;
|
|
// // }
|
|
// #endif /* BUILD_IEC */
|