Slic3r::StepPreProcessor Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/STEP.hpp>

Public Member Functions
bool	preprocess (const char *path, std::string &output_path)

Static Public Member Functions
static bool	isUtf8File (const char *path)
static bool	isUtf8 (const std::string str)

Private Types
enum class	EncodedType : unsigned char { UTF8 , GBK , OTHER }

Static Private Member Functions
static bool	isGBK (const std::string str)
static int	preNum (const unsigned char byte)

Private Attributes
EncodedType	m_encode_type = EncodedType::UTF8

Detailed Description

Member Enumeration Documentation

EncodedType

enum class Slic3r::StepPreProcessor::EncodedType : unsigned char

strongprivate

Enumerator
UTF8
GBK
OTHER

    {
        UTF8,
        GBK,
        OTHER
    };

Member Function Documentation

isGBK()

bool Slic3r::StepPreProcessor::isGBK ( const std::string str )

staticprivate

                                                {
    size_t i = 0;
    while (i < str.length()) {
        // char is signed here, so every byte compares <= 0x7f unless widened first.
        const unsigned char lead = static_cast<unsigned char>(str[i]);
        if (lead <= 0x7f) {
            i++;
            continue;
        } else {
            if (i + 1 >= str.length())
                return false;
            const unsigned char trail = static_cast<unsigned char>(str[i + 1]);
            if (lead >= 0x81 &&
                lead <= 0xfe &&
                trail >= 0x40 &&
                trail <= 0xfe &&
                trail != 0xf7) {
                i += 2;
                continue;
            }
            else {
                return false;
            }
        }
    }
    return true;
}

Referenced by preprocess().

Here is the caller graph for this function:

isUtf8()

bool Slic3r::StepPreProcessor::isUtf8 ( const std::string str )

static

{
    size_t num = 0;
    size_t i = 0;
    while (i < str.length()) {
        const unsigned char lead = static_cast<unsigned char>(str[i]);
        if ((lead & 0x80) == 0x00) {
            i++;
        // preNum() counts the leading 1 bits, and a multi-byte sequence is 2 to 4
        // bytes long, so anything outside that range is not a lead byte.
        } else if ((num = preNum(lead)) >= 2 && num <= 4) {
            if (i + num > str.length())
                return false;
            i++;
            for (size_t j = 0; j < num - 1; j++) {
                if ((static_cast<unsigned char>(str[i]) & 0xc0) != 0x80)
                    return false;
                i++;
            }
        } else {
            return false;
        }
    }
    return true;
}

References preNum().

Referenced by Slic3r::getNamedSolids(), isUtf8File(), and preprocess().

Here is the call graph for this function:

Here is the caller graph for this function:

isUtf8File()

bool Slic3r::StepPreProcessor::isUtf8File ( const char * path )

static

{
    boost::nowide::ifstream infile(path);
    if (!infile.good()) {
        throw Slic3r::RuntimeError(_u8L("Load step file failed.\nCannot open file for reading.\n"));
        return false;
    }
 
    std::string temp_line;
    while (std::getline(infile, temp_line)) {
        if (!isUtf8(temp_line)) {
            infile.close();
            return false;
        }
    }
 
    infile.close();
    return true;
}

References _u8L, and isUtf8().

Referenced by Slic3r::Step::load().

Here is the call graph for this function:

Here is the caller graph for this function:

preNum()

int Slic3r::StepPreProcessor::preNum ( const unsigned char byte )

staticprivate

                                                     {
    unsigned char mask = 0x80;
    int num = 0;
    for (int i = 0; i < 8; i++) {
        if ((byte & mask) == mask) {
            mask = mask >> 1;
            num++;
        } else {
            break;
        }
    }
    return num;
}

Referenced by isUtf8().

Here is the caller graph for this function:

preprocess()

bool Slic3r::StepPreProcessor::preprocess	(	const char *	path,
		std::string &	output_path )

{
    boost::nowide::ifstream infile(path);
    if (!infile.good()) {
        throw Slic3r::RuntimeError(_u8L("Load step file failed.\nCannot open file for reading.\n"));
        return false;
    }
 
    boost::filesystem::path temp_path(temporary_dir());
    std::string temp_step_path = temp_path.string() + "/temp.step";
    boost::nowide::remove(temp_step_path.c_str());
    boost::nowide::ofstream temp_file(temp_step_path, std::ios::app);
    std::string temp_line;
    while (std::getline(infile, temp_line)) {
        if (m_encode_type == EncodedType::UTF8) {
            //BBS: continue to judge whether is other type
            if (isUtf8(temp_line)) {
                //BBS: do nothing, but must be checked before checking whether is GBK
            }
            //BBS: not utf8, then maybe GBK
            else if (isGBK(temp_line)) {
                m_encode_type = EncodedType::GBK;
            }
            //BBS: not UTF8 and not GBK, then maybe some kind of special encoded type which we can't handle
            // Load the step as UTF and user will see garbage characters in slicer but we have no solution at the moment
            else {
                m_encode_type = EncodedType::OTHER;
            }
        }
        if (m_encode_type == EncodedType::GBK)
            //BBS: transform to UTF8 format if is GBK
            //todo: use gbkToUtf8 function to replace
            temp_file << decode_path(temp_line.c_str()) << std::endl;
        else
            temp_file << temp_line.c_str() << std::endl;
    }
    temp_file.close();
    infile.close();
    if (m_encode_type == EncodedType::GBK) {
        output_path = temp_step_path;
    } else {
        boost::nowide::remove(temp_step_path.c_str());
        output_path = std::string(path);
    }
 
    return true;
}

References _u8L, Slic3r::decode_path(), GBK, isGBK(), isUtf8(), m_encode_type, OTHER, Slic3r::temporary_dir(), and UTF8.

Here is the call graph for this function:

Member Data Documentation

m_encode_type

EncodedType Slic3r::StepPreProcessor::m_encode_type = EncodedType::UTF8

private

Referenced by preprocess().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/STEP.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Format/STEP.cpp