as2js: /home/snapwebsites/snapcpp/contrib/as2js/lib/stream.cpp Source File

as2js 0.1.14
AlexScript to JavaScript
 /* lib/stream.cpp
 
 Copyright (c) 2005-2019  Made to Order Software Corp.  All Rights Reserved
 
 https://snapwebsites.org/project/as2js
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and
 associated documentation files (the "Software"), to
 deal in the Software without restriction, including
 without limitation the rights to use, copy, modify,
 merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom
 the Software is furnished to do so, subject to the
 following conditions:
 
 The above copyright notice and this permission notice
 shall be included in all copies or substantial
 portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
 ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
 EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 */
 
 #include    "as2js/stream.h"
 
 #include    "as2js/exceptions.h"
 #include    "as2js/message.h"
 
 #include    <unistd.h>
 
 
 namespace as2js
 {
 
 /**********************************************************************/
 /**********************************************************************/
 /***  FILTERS  ********************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 
 DecodingFilter::~DecodingFilter()
 {
 }
 
 
 void DecodingFilter::putc(unsigned char c)
 {
     f_buffer.push_back(c);
 }
 
 
 Input::char_t DecodingFilter::getc()
 {
     if(f_buffer.empty())
     {
         return Input::INPUT_EOF;
     }
 
     return get_char();
 }
 
 
 Input::char_t DecodingFilterISO88591::get_char()
 {
     // no conversion for ISO-8859-1 to UTF-32
     Input::char_t c(f_buffer[0]);
     f_buffer.erase(f_buffer.begin());
     return c;
 }
 
 
 Input::char_t DecodingFilterUTF8::get_char()
 {
     // Note: we know that the buffer is at least 1 byte
     unsigned char b(f_buffer[0]);
 
     if(b < 0x80)
     {
         f_buffer.erase(f_buffer.begin());
         return b;
     }
 
     size_t l(0);
     as_char_t c(0);
     if(b >= 0xC0 && b <= 0xDF)
     {
         l = 2;
         c = b & 0x1F;
     }
     else if(b >= 0xE0 && b <= 0xEF)
     {
         l = 3;
         c = b & 0x0F;
     }
     else if(b >= 0xF0 && b <= 0xF7)
     {
         l = 4;
         c = b & 0x07;
     }
     else
     {
         // invalid UTF-8 sequence, erase one input byte
         f_buffer.erase(f_buffer.begin());
         return Input::INPUT_ERR;
     }
     if(f_buffer.size() < l)
     {
         // not enough bytes for this character
         return Input::INPUT_NAC;
     }
     for(size_t i(1); i < l; ++i)
     {
         b = f_buffer[i];
         if(b < 0x80 || b > 0xBF)
         {
             // found an invalid byte, remove bytes before that
             f_buffer.erase(f_buffer.begin(), f_buffer.begin() + i);
             return Input::INPUT_ERR;
         }
         c = (c << 6) | (b & 0x3F);
     }
 
     // get rid of those bytes
     f_buffer.erase(f_buffer.begin(), f_buffer.begin() + l);
 
     // is it a UTF-16 surrogate or too large a character?
     if(!String::valid_character(c))
     {
         return Input::INPUT_ERR;
     }
 
     // return that character
     return c;
 }
 
 
 Input::char_t DecodingFilterUTF16::next_char(Input::char_t c)
 {
     if(c >= 0xD800 && c < 0xDC00)
     {
         f_lead_surrogate = c;
         return Input::INPUT_NAC; // not an error unless it was the last 2 bytes
     }
     else if(c >= 0xDC00 && c <= 0xDFFF)
     {
         if(f_lead_surrogate == 0)
         {
             // lead surrogate missing, skip trail
             f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 2);
             return Input::INPUT_ERR;
         }
         c = (((static_cast<as_char_t>(f_lead_surrogate) & 0x03FF) << 10) | (static_cast<as_char_t>(c) & 0x03FF)) + 0x10000;
         f_lead_surrogate = 0;
     }
     else if(f_lead_surrogate != 0)
     {
         // trail surrogate missing
         f_lead_surrogate = 0;
         return Input::INPUT_ERR;
     }
 
     return c;
 }
 
 
 Input::char_t DecodingFilterUTF16LE::get_char()
 {
     Input::char_t c;
     do
     {
         if(f_buffer.size() < 2)
         {
             return Input::INPUT_NAC;
         }
 
         c = next_char(f_buffer[0] + f_buffer[1] * 256);
         if(c == Input::INPUT_ERR)
         {
             return Input::INPUT_ERR;
         }
         f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 2);
     }
     while(c == Input::INPUT_NAC);
 
     return c;
 }
 
 
 Input::char_t DecodingFilterUTF16BE::get_char()
 {
     Input::char_t c;
     do
     {
         if(f_buffer.size() < 2)
         {
             return Input::INPUT_NAC;
         }
 
         c = next_char(f_buffer[0] * 256 + f_buffer[1]);
         if(c == Input::INPUT_ERR)
         {
             return Input::INPUT_ERR;
         }
         f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 2);
     }
     while(c == Input::INPUT_NAC);
 
     return c;
 }
 
 
 Input::char_t DecodingFilterUTF32LE::get_char()
 {
     if(f_buffer.size() < 4)
     {
         return Input::INPUT_NAC;
     }
 
     // little endian has byte 0 as the least significant
     Input::char_t c(
               (f_buffer[0] <<  0)
             | (f_buffer[1] <<  8)
             | (f_buffer[2] << 16)
             | (f_buffer[3] << 24)
         );
     f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 4);
     if(!String::valid_character(c))
     {
         return Input::INPUT_ERR;
     }
     return c;
 }
 
 
 Input::char_t DecodingFilterUTF32BE::get_char()
 {
     if(f_buffer.size() < 4)
     {
         return Input::INPUT_NAC;
     }
 
     // big endian has byte 0 as the most significant
     Input::char_t c(
               (f_buffer[0] << 24)
             | (f_buffer[1] << 16)
             | (f_buffer[2] <<  8)
             | (f_buffer[3] <<  0)
         );
     f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 4);
     if(!String::valid_character(c))
     {
         return Input::INPUT_ERR;
     }
     return c;
 }
 
 
 Input::char_t DecodingFilterDetect::get_char()
 {
     if(!f_filter)
     {
         if(f_buffer.size() < 4)
         {
             return Input::INPUT_NAC;
         }
 
         // read the BOM in big endian
         uint32_t bom(
                   (f_buffer[0] << 24)
                 | (f_buffer[1] << 16)
                 | (f_buffer[2] <<  8)
                 | (f_buffer[3] <<  0)
             );
 
         if(bom == 0x0000FEFF)
         {
             // UTF-32 Big Endian
             f_filter.reset(new DecodingFilterUTF32BE);
             f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 4);
         }
         else if(bom == 0xFFFE0000)
         {
             // UTF-32 Little Endian
             f_filter.reset(new DecodingFilterUTF32LE);
             f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 4);
         }
         else if((bom >> 16) == 0xFEFF)
         {
             // UTF-16 Big Endian
             f_filter.reset(new DecodingFilterUTF16BE);
             f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 2);
         }
         else if((bom >> 16) == 0xFFFE)
         {
             // UTF-16 Little Endian
             f_filter.reset(new DecodingFilterUTF16LE);
             f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 2);
         }
         else if((bom & 0xFFFFFF00) == 0xEFBBBF00)
         {
             // UTF-8
             f_filter.reset(new DecodingFilterUTF8);
             f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 3);
         }
         else
         {
             // if each character is valid UTF-8, the use UTF-8
             String s;
             String::conversion_result_t r(s.from_utf8(reinterpret_cast<char const *>(&f_buffer[0]), f_buffer.size()));
             if(r == String::conversion_result_t::STRING_GOOD || r == String::conversion_result_t::STRING_END)
             {
                 f_filter.reset(new DecodingFilterUTF8);
             }
             else
             {
                 // fallback to ISO-8859-1 (should very rarely happen!)
                 f_filter.reset(new DecodingFilterISO88591);
             }
         }
     }
 
     // we do not get BOMs returned, yet we could check for the BOM
     // character and adjust the filter if we detect it being
     // swapped (it does not look like Unicode promotes that scheme
     // anymore though, therefore at this point we won't do that...)
 
     Input::char_t c(f_filter->getc());
     while((c == Input::INPUT_EOF || c == Input::INPUT_NAC)
        && !f_buffer.empty())
     {
         // transmit the data added to "this" filter
         // down to f_filter, but only as required
         // because otherwise we'd generate an EOF
         f_filter->putc(f_buffer[0]);
         f_buffer.erase(f_buffer.begin(), f_buffer.begin() + 1);
         c = f_filter->getc();
     }
 
     return c;
 }
 
 
 
 /**********************************************************************/
 /**********************************************************************/
 /***  INPUT  **********************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 
 Input::Input(DecodingFilter::pointer_t filter)
     : f_filter(filter)
     //, f_position() -- auto-init
     //, f_unget() -- auto-init
 {
 }
 
 
 Position& Input::get_position()
 {
     return f_position;
 }
 
 
 Position const& Input::get_position() const
 {
     return f_position;
 }
 
 
 Input::char_t Input::getc()
 {
     if(!f_unget.empty())
     {
         char_t result(f_unget.back());
         f_unget.pop_back();
         return result;
     }
     return filter_getc();
 }
 
 
 void Input::ungetc(char_t c)
 {
     // silently avoid ungetting special values such as INPUT_EOF
     // (TBD: maybe we should check surrogates?)
     if(c > 0 && c < 0x110000)
     {
         f_unget.push_back(c);
     }
 }
 
 
 Input::char_t Input::filter_getc()
 {
     // if the input class used does not overload this function,
     // then we get the next byte and try to convert it to a
     // character, if that works, return that character
 
     char_t w;
     do
     {
         char_t c(get_byte());
         if(c == Input::INPUT_EOF)
         {
             // determine the final result
             w = f_filter->getc();
             return w == Input::INPUT_NAC ? Input::INPUT_ERR : w;
         }
         f_filter->putc(c);
         w = f_filter->getc();
     }
     while(w == Input::INPUT_NAC || w == Input::INPUT_EOF);
     // EOF can happen if we bump in a BOM in the middle of nowhere
     // so we have to loop on EOF as well
 
     return w;
 }
 
 
 Input::char_t Input::get_byte()
 {
     // this function should never be called
     throw exception_internal_error("internal error: the get_byte() of the Input class was called");
 }
 
 
 /**********************************************************************/
 /**********************************************************************/
 /***  STANDARD INPUT  *************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 
 StandardInput::StandardInput()
 {
     get_position().set_filename("-");
 }
 
 
 Input::char_t StandardInput::get_byte()
 {
     char c;
     if(std::cin.get(c))
     {
         return static_cast<char_t>(c) & 255;
     }
     return INPUT_EOF;
 }
 
 
 /**********************************************************************/
 /**********************************************************************/
 /***  FILE INPUT  *****************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 
 bool FileInput::open(String const& filename)
 {
     if(f_file.is_open())
     {
         throw exception_file_already_open("file object for \"" + get_position().get_filename().to_utf8() + "\" cannot be reused for \"" + filename.to_utf8() + "\"");
     }
 
     std::string utf8(filename.to_utf8());
     f_file.open(utf8.c_str());
     if(!f_file.is_open())
     {
         return false;
     }
     get_position().set_filename(filename);
 
     return true;
 }
 
 
 Input::char_t FileInput::get_byte()
 {
     char c;
     if(f_file.get(c))
     {
         return static_cast<char_t>(c) & 255;
     }
     return INPUT_EOF;
 }
 
 
 
 
 /**********************************************************************/
 /**********************************************************************/
 /***  STRING INPUT  ***************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 StringInput::StringInput(String const& str, Position::counter_t line)
     : f_str(str)
     //, f_pos(0) -- auto-init
 {
     // in case line is not set to 1
     get_position().reset_counters(line);
 }
 
 
 Input::char_t StringInput::filter_getc() // bypass the filters
 {
     char_t  c(INPUT_EOF);
 
     if(f_pos < f_str.length())
     {
         c = f_str[f_pos];
         ++f_pos;
     }
     return c;
 }
 
 
 
 
 /**********************************************************************/
 /**********************************************************************/
 /***  OUTPUT  *********************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 
 Position& Output::get_position()
 {
     return f_position;
 }
 
 
 Position const& Output::get_position() const
 {
     return f_position;
 }
 
 
 void Output::write(String const& data)
 {
     internal_write(data);
 }
 
 
 /**********************************************************************/
 /**********************************************************************/
 /***  STANDARD OUTPUT  ************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 StandardOutput::StandardOutput()
 {
     get_position().set_filename("-");
 }
 
 
 void StandardOutput::internal_write(String const& data)
 {
     std::cout << data.to_utf8();
     if(!std::cout)
     {
         // should we do something here?
         Message msg(message_level_t::MESSAGE_LEVEL_FATAL, err_code_t::AS_ERR_IO_ERROR, get_position());
         msg << "I/O error: could not write to output.";
         throw exception_exit(1, "I/O error: could not write to output.");
     }
 }
 
 
 /**********************************************************************/
 /**********************************************************************/
 /***  OUTPUT FILE  ****************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 
 bool FileOutput::open(String const& filename)
 {
     if(f_file.is_open())
     {
         throw exception_file_already_open("file object for \"" + get_position().get_filename().to_utf8() + "\" cannot be reused for \"" + filename.to_utf8() + "\"");
     }
 
     std::string utf8(filename.to_utf8());
     f_file.open(utf8.c_str());
     if(!f_file.is_open())
     {
         return false;
     }
     get_position().set_filename(filename);
 
     return true;
 }
 
 
 void FileOutput::internal_write(String const& data)
 {
     f_file << data.to_utf8();
     if(!f_file)
     {
         // should we do something here?
         Message msg(message_level_t::MESSAGE_LEVEL_FATAL, err_code_t::AS_ERR_IO_ERROR, get_position());
         msg << "I/O error: could not write to output.";
         throw exception_exit(1, "I/O error: could not write to output.");
     }
 }
 
 
 /**********************************************************************/
 /**********************************************************************/
 /***  OUTPUT STRING  **************************************************/
 /**********************************************************************/
 /**********************************************************************/
 
 
 String const& StringOutput::get_string() const
 {
     return f_string;
 }
 
 
 void StringOutput::internal_write(String const& data)
 {
     f_string += data;
 }
 
 
 }
 // namespace as2js
 
 // vim: ts=4 sw=4 et
This document is part of the Snap! Websites Project.
Snap! Websites
An Open Source CMS System in C++
Snap! A C++ Open Source CMS

as2js: /home/snapwebsites/snapcpp/contrib/as2js/lib/stream.cpp Source File

Recent Posts

Recent blog posts
