FileIO Namespace Reference

Functions
uint16_t	read16 (std::ifstream &fin, Endianness e=Endianness::NATIVE)
uint32_t	read32 (std::ifstream &fin, Endianness e=Endianness::NATIVE)
uint64_t	read64 (std::ifstream &fin, Endianness e=Endianness::NATIVE)
uint8_t	read8 (std::ifstream &fin, Endianness e=Endianness::NATIVE)
uint16_t	readBigEndian16 (std::ifstream &fin)
uint32_t	readBigEndian32 (std::ifstream &fin)
uint64_t	readBigEndian64 (std::ifstream &fin)
uint8_t	readBigEndian8 (std::ifstream &fin)
uint16_t	readBitSwappedBigEndian16 (std::ifstream &fin)
uint32_t	readBitSwappedBigEndian32 (std::ifstream &fin)
uint64_t	readBitSwappedBigEndian64 (std::ifstream &fin)
uint8_t	readBitSwappedBigEndian8 (std::ifstream &fin)
uint16_t	readBitSwappedLittleEndian16 (std::ifstream &fin)
uint32_t	readBitSwappedLittleEndian32 (std::ifstream &fin)
uint64_t	readBitSwappedLittleEndian64 (std::ifstream &fin)
uint8_t	readBitSwappedLittleEndian8 (std::ifstream &fin)
std::string	readBitSwappedString (std::ifstream &fin, int stringSize)
char *	readBitSwappedStringIntoCharArray (std::ifstream &fin, int stringSize)
uint16_t	readLittleEndian16 (std::ifstream &fin)
uint32_t	readLittleEndian32 (std::ifstream &fin)
uint64_t	readLittleEndian64 (std::ifstream &fin)
uint8_t	readLittleEndian8 (std::ifstream &fin)
uint16_t	readNative16 (std::ifstream &fin)
uint32_t	readNative32 (std::ifstream &fin)
uint64_t	readNative64 (std::ifstream &fin)
uint8_t	readNative8 (std::ifstream &fin)
std::string	readString (std::ifstream &fin, int stringSize)
std::string	readString (std::ifstream &fin, int stringSize, Endianness e)
char *	readStringIntoCharArray (std::ifstream &fin, int stringSize)
char *	readStringIntoCharArray (std::ifstream &fin, int stringSize, Endianness e)
void	write16 (std::ofstream &fout, uint16_t writeValue, Endianness e=Endianness::NATIVE)
void	write32 (std::ofstream &fout, uint32_t writeValue, Endianness e=Endianness::NATIVE)
void	write64 (std::ofstream &fout, uint64_t writeValue, Endianness e=Endianness::NATIVE)
void	write8 (std::ofstream &fout, uint8_t writeValue, Endianness e=Endianness::NATIVE)
void	writeBigEndian16 (std::ofstream &fout, uint16_t writeValue)
void	writeBigEndian32 (std::ofstream &fout, uint32_t writeValue)
void	writeBigEndian64 (std::ofstream &fout, uint64_t writeValue)
void	writeBigEndian8 (std::ofstream &fout, uint8_t writeValue)
void	writeBitSwappedBigEndian16 (std::ofstream &fout, uint16_t writeValue)
void	writeBitSwappedBigEndian32 (std::ofstream &fout, uint32_t writeValue)
void	writeBitSwappedBigEndian64 (std::ofstream &fout, uint64_t writeValue)
void	writeBitSwappedBigEndian8 (std::ofstream &fout, uint8_t writeValue)
void	writeBitSwappedCharArray (std::ofstream &fout, char *writeCharArray, size_t outputSize=0)
void	writeBitSwappedLittleEndian16 (std::ofstream &fout, uint16_t writeValue)
void	writeBitSwappedLittleEndian32 (std::ofstream &fout, uint32_t writeValue)
void	writeBitSwappedLittleEndian64 (std::ofstream &fout, uint64_t writeValue)
void	writeBitSwappedLittleEndian8 (std::ofstream &fout, uint8_t writeValue)
void	writeBitSwappedString (std::ofstream &fout, std::string writeString, size_t outputSize=0)
void	writeCharArray (std::ofstream &fout, char *writeCharArray, Endianness e)
void	writeCharArray (std::ofstream &fout, char *writeCharArray, size_t outputSize, Endianness e)
void	writeCharArray (std::ofstream &fout, char *writeCharArray, size_t outputSize=0)
void	writeLittleEndian16 (std::ofstream &fout, uint16_t writeValue)
void	writeLittleEndian32 (std::ofstream &fout, uint32_t writeValue)
void	writeLittleEndian64 (std::ofstream &fout, uint64_t writeValue)
void	writeLittleEndian8 (std::ofstream &fout, uint8_t writeValue)
void	writeNative16 (std::ofstream &fout, uint16_t writeValue)
void	writeNative32 (std::ofstream &fout, uint32_t writeValue)
void	writeNative64 (std::ofstream &fout, uint64_t writeValue)
void	writeNative8 (std::ofstream &fout, uint8_t writeValue)
void	writeString (std::ofstream &fout, std::string writeString, Endianness e)
void	writeString (std::ofstream &fout, std::string writeString, size_t outputSize, Endianness e)
void	writeString (std::ofstream &fout, std::string writeString, size_t outputSize=0)

Function Documentation

read16()

uint16_t FileIO::read16 ( std::ifstream &  fin, Endianness  e = Endianness::NATIVE  )

inline

Definition at line 143 of file FileIO.h.

    {
        if(e == Endianness::BE)
            return FileIO::readBigEndian16(fin);
        else if(e == Endianness::LE)
            return FileIO::readLittleEndian16(fin);
        else if(e == Endianness::BE_BS)
            return FileIO::readBitSwappedBigEndian16(fin);
        else if(e == Endianness::LE_BS)
            return FileIO::readBitSwappedLittleEndian16(fin);
        return FileIO::readNative16(fin);
    }

References BE, BE_BS, LE, LE_BS, readBigEndian16(), readBitSwappedBigEndian16(), readBitSwappedLittleEndian16(), readLittleEndian16(), and readNative16().

Referenced by parseBITheader().

Here is the call graph for this function:

Here is the caller graph for this function:

read32()

uint32_t FileIO::read32 ( std::ifstream &  fin, Endianness  e = Endianness::NATIVE  )

inline

Definition at line 131 of file FileIO.h.

    {
        if(e == Endianness::BE)
            return FileIO::readBigEndian32(fin);
        else if(e == Endianness::LE)
            return FileIO::readLittleEndian32(fin);
        else if(e == Endianness::BE_BS)
            return FileIO::readBitSwappedBigEndian32(fin);
        else if(e == Endianness::LE_BS)
            return FileIO::readBitSwappedLittleEndian32(fin);
        return FileIO::readNative32(fin);
    }

References BE, BE_BS, LE, LE_BS, readBigEndian32(), readBitSwappedBigEndian32(), readBitSwappedLittleEndian32(), readLittleEndian32(), and readNative32().

Referenced by assemblyOutputData(), XilinxSeries7::disassemblerToAsm(), XilinxUltraScale::disassemblerToAsm(), XilinxUltraScalePlus::disassemblerToAsm(), findBitstreamSyncSequence(), findBitstreamSyncWord(), parseBITheader(), parseBitstreamEndianness(), parseBitstreamIDCODE(), and readBitstreamMain().

Here is the call graph for this function:

Here is the caller graph for this function:

read64()

uint64_t FileIO::read64 ( std::ifstream &  fin, Endianness  e = Endianness::NATIVE  )

inline

Definition at line 119 of file FileIO.h.

    {
        if(e == Endianness::BE)
            return FileIO::readBigEndian64(fin);
        else if(e == Endianness::LE)
            return FileIO::readLittleEndian64(fin);
        else if(e == Endianness::BE_BS)
            return FileIO::readBitSwappedBigEndian64(fin);
        else if(e == Endianness::LE_BS)
            return FileIO::readBitSwappedLittleEndian64(fin);
        return FileIO::readNative64(fin);
    }

References BE, BE_BS, LE, LE_BS, readBigEndian64(), readBitSwappedBigEndian64(), readBitSwappedLittleEndian64(), readLittleEndian64(), and readNative64().

Here is the call graph for this function:

read8()

uint8_t FileIO::read8 ( std::ifstream &  fin, Endianness  e = Endianness::NATIVE  )

inline

Definition at line 155 of file FileIO.h.

    {
        if(e == Endianness::BE)
            return FileIO::readBigEndian8(fin);
        else if(e == Endianness::LE)
            return FileIO::readLittleEndian8(fin);
        else if(e == Endianness::BE_BS)
            return FileIO::readBitSwappedBigEndian8(fin);
        else if(e == Endianness::LE_BS)
            return FileIO::readBitSwappedLittleEndian8(fin);
        return FileIO::readNative8(fin);
    }

References BE, BE_BS, LE, LE_BS, readBigEndian8(), readBitSwappedBigEndian8(), readBitSwappedLittleEndian8(), readLittleEndian8(), and readNative8().

Here is the call graph for this function:

readBigEndian16()

uint16_t FileIO::readBigEndian16 ( std::ifstream &  fin )

inline

Definition at line 60 of file FileIO.h.

    {
        return Endian::NativeToBigEndian16(FileIO::readNative16(fin));
    }

References Endian::NativeToBigEndian16(), and readNative16().

Referenced by read16(), and readBitSwappedBigEndian16().

Here is the call graph for this function:

Here is the caller graph for this function:

readBigEndian32()

uint32_t FileIO::readBigEndian32 ( std::ifstream &  fin )

inline

Definition at line 56 of file FileIO.h.

    {
        return Endian::NativeToBigEndian32(FileIO::readNative32(fin));
    }

References Endian::NativeToBigEndian32(), and readNative32().

Referenced by read32(), and readBitSwappedBigEndian32().

Here is the call graph for this function:

Here is the caller graph for this function:

readBigEndian64()

uint64_t FileIO::readBigEndian64 ( std::ifstream &  fin )

inline

Definition at line 52 of file FileIO.h.

    {
        return Endian::NativeToBigEndian64(FileIO::readNative64(fin));
    }

References Endian::NativeToBigEndian64(), and readNative64().

Referenced by read64(), and readBitSwappedBigEndian64().

Here is the call graph for this function:

Here is the caller graph for this function:

readBigEndian8()

uint8_t FileIO::readBigEndian8 ( std::ifstream &  fin )

inline

Definition at line 64 of file FileIO.h.

    {
        return readNative8(fin);
    }

References readNative8().

Referenced by read8(), and readBitSwappedBigEndian8().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedBigEndian16()

uint16_t FileIO::readBitSwappedBigEndian16 ( std::ifstream &  fin )

inline

Definition at line 94 of file FileIO.h.

    {
        return Endian::BitSwap16(FileIO::readBigEndian16(fin));
    }

References Endian::BitSwap16(), and readBigEndian16().

Referenced by read16().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedBigEndian32()

uint32_t FileIO::readBitSwappedBigEndian32 ( std::ifstream &  fin )

inline

Definition at line 90 of file FileIO.h.

    {
        return Endian::BitSwap32(FileIO::readBigEndian32(fin));
    }

References Endian::BitSwap32(), and readBigEndian32().

Referenced by read32().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedBigEndian64()

uint64_t FileIO::readBitSwappedBigEndian64 ( std::ifstream &  fin )

inline

Definition at line 86 of file FileIO.h.

    {
        return Endian::BitSwap64(FileIO::readBigEndian64(fin));
    }

References Endian::BitSwap64(), and readBigEndian64().

Referenced by read64().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedBigEndian8()

uint8_t FileIO::readBitSwappedBigEndian8 ( std::ifstream &  fin )

inline

Definition at line 98 of file FileIO.h.

    {
        return Endian::BitSwap8(FileIO::readBigEndian8(fin));
    }

References Endian::BitSwap8(), and readBigEndian8().

Referenced by read8().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedLittleEndian16()

uint16_t FileIO::readBitSwappedLittleEndian16 ( std::ifstream &  fin )

inline

Definition at line 111 of file FileIO.h.

    {
        return Endian::BitSwap16(FileIO::readLittleEndian16(fin));
    }

References Endian::BitSwap16(), and readLittleEndian16().

Referenced by read16().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedLittleEndian32()

uint32_t FileIO::readBitSwappedLittleEndian32 ( std::ifstream &  fin )

inline

Definition at line 107 of file FileIO.h.

    {
        return Endian::BitSwap32(FileIO::readLittleEndian32(fin));
    }

References Endian::BitSwap32(), and readLittleEndian32().

Referenced by read32().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedLittleEndian64()

uint64_t FileIO::readBitSwappedLittleEndian64 ( std::ifstream &  fin )

inline

Definition at line 103 of file FileIO.h.

    {
        return Endian::BitSwap64(FileIO::readLittleEndian64(fin));
    }

References Endian::BitSwap64(), and readLittleEndian64().

Referenced by read64().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedLittleEndian8()

uint8_t FileIO::readBitSwappedLittleEndian8 ( std::ifstream &  fin )

inline

Definition at line 115 of file FileIO.h.

    {
        return Endian::BitSwap8(FileIO::readLittleEndian8(fin));
    }

References Endian::BitSwap8(), and readLittleEndian8().

Referenced by read8().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedString()

std::string FileIO::readBitSwappedString ( std::ifstream &  fin, int  stringSize  )

inline

Definition at line 191 of file FileIO.h.

    {
        char* readCharArray = readBitSwappedStringIntoCharArray(fin, stringSize);
        std::string returnString = std::string(readCharArray);
        delete readCharArray;
        return returnString;
    }

References readBitSwappedStringIntoCharArray().

Referenced by readString().

Here is the call graph for this function:

Here is the caller graph for this function:

readBitSwappedStringIntoCharArray()

char* FileIO::readBitSwappedStringIntoCharArray ( std::ifstream &  fin, int  stringSize  )

inline

Definition at line 184 of file FileIO.h.

    {
        char* readCharArray = FileIO::readStringIntoCharArray(fin, stringSize);
        for(int i = 0 ; i < stringSize ; i++)
            readCharArray[i] = Endian::BitSwap8(readCharArray[i]);
        return readCharArray;
    }

References Endian::BitSwap8(), and readStringIntoCharArray().

Referenced by readBitSwappedString(), and readStringIntoCharArray().

Here is the call graph for this function:

Here is the caller graph for this function:

readLittleEndian16()

uint16_t FileIO::readLittleEndian16 ( std::ifstream &  fin )

inline

Definition at line 77 of file FileIO.h.

    {
        return Endian::NativeToLittleEndian16(FileIO::readNative16(fin));
    }

References Endian::NativeToLittleEndian16(), and readNative16().

Referenced by read16(), and readBitSwappedLittleEndian16().

Here is the call graph for this function:

Here is the caller graph for this function:

readLittleEndian32()

uint32_t FileIO::readLittleEndian32 ( std::ifstream &  fin )

inline

Definition at line 73 of file FileIO.h.

    {
        return Endian::NativeToLittleEndian32(FileIO::readNative32(fin));
    }

References Endian::NativeToLittleEndian32(), and readNative32().

Referenced by read32(), and readBitSwappedLittleEndian32().

Here is the call graph for this function:

Here is the caller graph for this function:

readLittleEndian64()

uint64_t FileIO::readLittleEndian64 ( std::ifstream &  fin )

inline

Definition at line 69 of file FileIO.h.

    {
        return Endian::NativeToLittleEndian64(FileIO::readNative64(fin));
    }

References Endian::NativeToLittleEndian64(), and readNative64().

Referenced by read64(), and readBitSwappedLittleEndian64().

Here is the call graph for this function:

Here is the caller graph for this function:

readLittleEndian8()

uint8_t FileIO::readLittleEndian8 ( std::ifstream &  fin )

inline

Definition at line 81 of file FileIO.h.

    {
        return readNative8(fin);
    }

References readNative8().

Referenced by read8(), and readBitSwappedLittleEndian8().

Here is the call graph for this function:

Here is the caller graph for this function:

readNative16()

uint16_t FileIO::readNative16 ( std::ifstream &  fin )

inline

Definition at line 40 of file FileIO.h.

    {
        uint16_t readValue;
        fin.read(reinterpret_cast<char*>(&readValue), 2);
        return readValue;
    }

Referenced by read16(), readBigEndian16(), and readLittleEndian16().

Here is the caller graph for this function:

readNative32()

uint32_t FileIO::readNative32 ( std::ifstream &  fin )

inline

Definition at line 34 of file FileIO.h.

    {
        uint32_t readValue;
        fin.read(reinterpret_cast<char*>(&readValue), 4);
        return readValue;
    }

Referenced by read32(), readBigEndian32(), and readLittleEndian32().

Here is the caller graph for this function:

readNative64()

uint64_t FileIO::readNative64 ( std::ifstream &  fin )

inline

Definition at line 28 of file FileIO.h.

    {
        uint64_t readValue;
        fin.read(reinterpret_cast<char*>(&readValue), 8);
        return readValue;
    }

Referenced by read64(), readBigEndian64(), and readLittleEndian64().

Here is the caller graph for this function:

readNative8()

uint8_t FileIO::readNative8 ( std::ifstream &  fin )

inline

Definition at line 46 of file FileIO.h.

    {
        uint8_t readValue;
        fin.read(reinterpret_cast<char*>(&readValue), 1);
        return readValue;
    }

Referenced by parseBITheader(), read8(), readBigEndian8(), and readLittleEndian8().

Here is the caller graph for this function:

readString() [1/2]

std::string FileIO::readString ( std::ifstream &  fin, int  stringSize  )

inline

Definition at line 176 of file FileIO.h.

    {
        char* readCharArray = readStringIntoCharArray(fin, stringSize);
        std::string returnString = std::string(readCharArray);
        delete readCharArray;
        return returnString;
    }

References readStringIntoCharArray().

Referenced by parseBITheader(), and readString().

Here is the call graph for this function:

Here is the caller graph for this function:

readString() [2/2]

std::string FileIO::readString ( std::ifstream &  fin, int  stringSize, Endianness  e  )

inline

Definition at line 206 of file FileIO.h.

    {
        if(e == Endianness::BE_BS || e == Endianness::LE_BS)
            return FileIO::readBitSwappedString(fin, stringSize);
        else
            return FileIO::readString(fin, stringSize);
    }

References BE_BS, LE_BS, readBitSwappedString(), and readString().

Here is the call graph for this function:

readStringIntoCharArray() [1/2]

char* FileIO::readStringIntoCharArray ( std::ifstream &  fin, int  stringSize  )

inline

Definition at line 169 of file FileIO.h.

    {
        char* readCharArray = new char[stringSize + 1];
        fin.read(readCharArray, stringSize);
        readCharArray[stringSize]='\0';
        return readCharArray;
    }

Referenced by readBitSwappedStringIntoCharArray(), readString(), and readStringIntoCharArray().

Here is the caller graph for this function:

readStringIntoCharArray() [2/2]

char* FileIO::readStringIntoCharArray ( std::ifstream &  fin, int  stringSize, Endianness  e  )

inline

Definition at line 199 of file FileIO.h.

    {
        if(e == Endianness::BE_BS || e == Endianness::LE_BS)
            return FileIO::readBitSwappedStringIntoCharArray(fin, stringSize);
        else
            return FileIO::readStringIntoCharArray(fin, stringSize);
    }

References BE_BS, LE_BS, readBitSwappedStringIntoCharArray(), and readStringIntoCharArray().

Here is the call graph for this function:

write16()

void FileIO::write16 ( std::ofstream &  fout, uint16_t  writeValue, Endianness  e = Endianness::NATIVE  )

inline

Definition at line 432 of file FileIO.h.

    {
        if(e == Endianness::NATIVE)
            FileIO::writeNative16(fout, writeValue);
        else if(e == Endianness::BE)
            FileIO::writeBigEndian16(fout, writeValue);
        else if(e == Endianness::LE)
            FileIO::writeLittleEndian16(fout, writeValue);
        else if(e == Endianness::BE_BS)
            FileIO::writeBitSwappedBigEndian16(fout, writeValue);
        else if(e == Endianness::LE_BS)
            FileIO::writeBitSwappedLittleEndian16(fout, writeValue);
    }

References BE, BE_BS, LE, LE_BS, NATIVE, writeBigEndian16(), writeBitSwappedBigEndian16(), writeBitSwappedLittleEndian16(), writeLittleEndian16(), and writeNative16().

Referenced by outputBITheader(), and outputBITheader16bString().

Here is the call graph for this function:

Here is the caller graph for this function:

write32()

void FileIO::write32 ( std::ofstream &  fout, uint32_t  writeValue, Endianness  e = Endianness::NATIVE  )

inline

Definition at line 419 of file FileIO.h.

    {
        if(e == Endianness::NATIVE)
            FileIO::writeNative32(fout, writeValue);
        else if(e == Endianness::BE)
            FileIO::writeBigEndian32(fout, writeValue);
        else if(e == Endianness::LE)
            FileIO::writeLittleEndian32(fout, writeValue);
        else if(e == Endianness::BE_BS)
            FileIO::writeBitSwappedBigEndian32(fout, writeValue);
        else if(e == Endianness::LE_BS)
            FileIO::writeBitSwappedLittleEndian32(fout, writeValue);
    }

References BE, BE_BS, LE, LE_BS, NATIVE, writeBigEndian32(), writeBitSwappedBigEndian32(), writeBitSwappedLittleEndian32(), writeLittleEndian32(), and writeNative32().

Referenced by XilinxSeries7::assemblerAsmTo(), XilinxUltraScale::assemblerAsmTo(), XilinxUltraScalePlus::assemblerAsmTo(), outputBITheader(), outputBITheaderLengthField(), XilinxSeries7::outputBitstreamEmptySLRWrapUpSequence(), XilinxUltraScale::outputBitstreamEmptySLRWrapUpSequence(), XilinxUltraScalePlus::outputBitstreamEmptySLRWrapUpSequence(), XilinxSeries7::outputBitstreamSLRWrapUpSequence(), XilinxUltraScale::outputBitstreamSLRWrapUpSequence(), XilinxUltraScalePlus::outputBitstreamSLRWrapUpSequence(), outputCAPheaderConstant(), XCAP_writeFDRI1(), XCAP_writeNOP(), XCAP_writeReadRegister(), XCAP_writeRegister(), XCAP_writeRESERVED(), XCAP_writeSelectRegister(), XCAP_writeSYNQ(), and XCAP_writeType2().

Here is the call graph for this function:

Here is the caller graph for this function:

write64()

void FileIO::write64 ( std::ofstream &  fout, uint64_t  writeValue, Endianness  e = Endianness::NATIVE  )

inline

Definition at line 406 of file FileIO.h.

    {
        if(e == Endianness::NATIVE)
            FileIO::writeNative64(fout, writeValue);
        else if(e == Endianness::BE)
            FileIO::writeBigEndian64(fout, writeValue);
        else if(e == Endianness::LE)
            FileIO::writeLittleEndian64(fout, writeValue);
        else if(e == Endianness::BE_BS)
            FileIO::writeBitSwappedBigEndian64(fout, writeValue);
        else if(e == Endianness::LE_BS)
            FileIO::writeBitSwappedLittleEndian64(fout, writeValue);
    }

References BE, BE_BS, LE, LE_BS, NATIVE, writeBigEndian64(), writeBitSwappedBigEndian64(), writeBitSwappedLittleEndian64(), writeLittleEndian64(), and writeNative64().

Here is the call graph for this function:

write8()

void FileIO::write8 ( std::ofstream &  fout, uint8_t  writeValue, Endianness  e = Endianness::NATIVE  )

inline

Definition at line 445 of file FileIO.h.

    {
        if(e == Endianness::NATIVE)
            FileIO::writeNative8(fout, writeValue);
        else if(e == Endianness::BE)
            FileIO::writeBigEndian8(fout, writeValue);
        else if(e == Endianness::LE)
            FileIO::writeLittleEndian8(fout, writeValue);
        else if(e == Endianness::BE_BS)
            FileIO::writeBitSwappedBigEndian8(fout, writeValue);
        else if(e == Endianness::LE_BS)
            FileIO::writeBitSwappedLittleEndian8(fout, writeValue);
    }

References BE, BE_BS, LE, LE_BS, NATIVE, writeBigEndian8(), writeBitSwappedBigEndian8(), writeBitSwappedLittleEndian8(), writeLittleEndian8(), and writeNative8().

Referenced by XilinxSeries7::assemblerAsmTo(), XilinxUltraScale::assemblerAsmTo(), XilinxUltraScalePlus::assemblerAsmTo(), and outputBITheader().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBigEndian16()

void FileIO::writeBigEndian16 ( std::ofstream &  fout, uint16_t  writeValue  )

inline

Definition at line 241 of file FileIO.h.

    {
        uint16_t writeValueBigEndian = Endian::BigEndianToNative16(writeValue);
        fout.write(reinterpret_cast<char*>(&writeValueBigEndian), sizeof(writeValueBigEndian));
    }

References Endian::BigEndianToNative16().

Referenced by write16().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBigEndian32()

void FileIO::writeBigEndian32 ( std::ofstream &  fout, uint32_t  writeValue  )

inline

Definition at line 236 of file FileIO.h.

    {
        uint32_t writeValueBigEndian = Endian::BigEndianToNative32(writeValue);
        fout.write(reinterpret_cast<char*>(&writeValueBigEndian), sizeof(writeValueBigEndian));
    }

References Endian::BigEndianToNative32().

Referenced by write32().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBigEndian64()

void FileIO::writeBigEndian64 ( std::ofstream &  fout, uint64_t  writeValue  )

inline

Definition at line 231 of file FileIO.h.

    {
        uint64_t writeValueBigEndian = Endian::BigEndianToNative64(writeValue);
        fout.write(reinterpret_cast<char*>(&writeValueBigEndian), sizeof(writeValueBigEndian));
    }

References Endian::BigEndianToNative64().

Referenced by write64().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBigEndian8()

void FileIO::writeBigEndian8 ( std::ofstream &  fout, uint8_t  writeValue  )

inline

Definition at line 246 of file FileIO.h.

    {
        uint8_t writeValueBigEndian = Endian::BigEndianToNative8(writeValue);
        fout.write(reinterpret_cast<char*>(&writeValueBigEndian), sizeof(writeValueBigEndian));
    }

References Endian::BigEndianToNative8().

Referenced by write8().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedBigEndian16()

void FileIO::writeBitSwappedBigEndian16 ( std::ofstream &  fout, uint16_t  writeValue  )

inline

Definition at line 285 of file FileIO.h.

    {
        uint16_t writeValueByteSwapped = Endian::BitSwap16(writeValue);
        uint16_t writeValueByteSwappedBigEndian = Endian::BigEndianToNative16(writeValueByteSwapped);
        fout.write(reinterpret_cast<char*>(&writeValueByteSwappedBigEndian), sizeof(writeValueByteSwappedBigEndian));
    }

References Endian::BigEndianToNative16(), and Endian::BitSwap16().

Referenced by write16().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedBigEndian32()

void FileIO::writeBitSwappedBigEndian32 ( std::ofstream &  fout, uint32_t  writeValue  )

inline

Definition at line 279 of file FileIO.h.

    {
        uint32_t writeValueByteSwapped = Endian::BitSwap32(writeValue);
        uint32_t writeValueByteSwappedBigEndian = Endian::BigEndianToNative32(writeValueByteSwapped);
        fout.write(reinterpret_cast<char*>(&writeValueByteSwappedBigEndian), sizeof(writeValueByteSwappedBigEndian));
    }

References Endian::BigEndianToNative32(), and Endian::BitSwap32().

Referenced by write32().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedBigEndian64()

void FileIO::writeBitSwappedBigEndian64 ( std::ofstream &  fout, uint64_t  writeValue  )

inline

Definition at line 273 of file FileIO.h.

    {
        uint64_t writeValueByteSwapped = Endian::BitSwap64(writeValue);
        uint64_t writeValueByteSwappedBigEndian = Endian::BigEndianToNative64(writeValueByteSwapped);
        fout.write(reinterpret_cast<char*>(&writeValueByteSwappedBigEndian), sizeof(writeValueByteSwappedBigEndian));
    }

References Endian::BigEndianToNative64(), and Endian::BitSwap64().

Referenced by write64().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedBigEndian8()

void FileIO::writeBitSwappedBigEndian8 ( std::ofstream &  fout, uint8_t  writeValue  )

inline

Definition at line 291 of file FileIO.h.

    {
        uint8_t writeValueByteSwapped = Endian::BitSwap8(writeValue);
        uint8_t writeValueByteSwappedBigEndian = Endian::BigEndianToNative8(writeValueByteSwapped);
        fout.write(reinterpret_cast<char*>(&writeValueByteSwappedBigEndian), sizeof(writeValueByteSwappedBigEndian));
    }

References Endian::BigEndianToNative8(), and Endian::BitSwap8().

Referenced by write8().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedCharArray()

void FileIO::writeBitSwappedCharArray ( std::ofstream &  fout, char *  writeCharArray, size_t  outputSize = 0  )

inline

Definition at line 344 of file FileIO.h.

    {
        uint8_t nextChar = 0;
        size_t charArraySize = 1;
        for( ; (0 != writeCharArray[charArraySize-1] && charArraySize != outputSize); charArraySize++);
        for(size_t i = 0 ; i < charArraySize ; i++){
            nextChar = Endian::BitSwap8(writeCharArray[i]);
            fout.write(reinterpret_cast<char*>(&nextChar), 1);
        }
        nextChar = 0;
        for( ; charArraySize < outputSize ; charArraySize++)
            fout.write(reinterpret_cast<char*>(&nextChar), 1);
    }

References Endian::BitSwap8(), and writeCharArray().

Referenced by writeCharArray().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedLittleEndian16()

void FileIO::writeBitSwappedLittleEndian16 ( std::ofstream &  fout, uint16_t  writeValue  )

inline

Definition at line 310 of file FileIO.h.

    {
        uint16_t writeValueByteSwapped = Endian::BitSwap16(writeValue);
        uint16_t writeValueByteSwappedLittleEndian = Endian::LittleEndianToNative16(writeValueByteSwapped);
        fout.write(reinterpret_cast<char*>(&writeValueByteSwappedLittleEndian), sizeof(writeValueByteSwappedLittleEndian));
    }

References Endian::BitSwap16(), and Endian::LittleEndianToNative16().

Referenced by write16().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedLittleEndian32()

void FileIO::writeBitSwappedLittleEndian32 ( std::ofstream &  fout, uint32_t  writeValue  )

inline

Definition at line 304 of file FileIO.h.

    {
        uint32_t writeValueByteSwapped = Endian::BitSwap32(writeValue);
        uint32_t writeValueByteSwappedLittleEndian = Endian::LittleEndianToNative32(writeValueByteSwapped);
        fout.write(reinterpret_cast<char*>(&writeValueByteSwappedLittleEndian), sizeof(writeValueByteSwappedLittleEndian));
    }

References Endian::BitSwap32(), and Endian::LittleEndianToNative32().

Referenced by write32().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedLittleEndian64()

void FileIO::writeBitSwappedLittleEndian64 ( std::ofstream &  fout, uint64_t  writeValue  )

inline

Definition at line 298 of file FileIO.h.

    {
        uint64_t writeValueByteSwapped = Endian::BitSwap64(writeValue);
        uint64_t writeValueByteSwappedLittleEndian = Endian::LittleEndianToNative64(writeValueByteSwapped);
        fout.write(reinterpret_cast<char*>(&writeValueByteSwappedLittleEndian), sizeof(writeValueByteSwappedLittleEndian));
    }

References Endian::BitSwap64(), and Endian::LittleEndianToNative64().

Referenced by write64().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedLittleEndian8()

void FileIO::writeBitSwappedLittleEndian8 ( std::ofstream &  fout, uint8_t  writeValue  )

inline

Definition at line 316 of file FileIO.h.

    {
        uint8_t writeValueByteSwapped = Endian::BitSwap8(writeValue);
        uint8_t writeValueByteSwappedLittleEndian = Endian::LittleEndianToNative8(writeValueByteSwapped);
        fout.write(reinterpret_cast<char*>(&writeValueByteSwappedLittleEndian), sizeof(writeValueByteSwappedLittleEndian));
    }

References Endian::BitSwap8(), and Endian::LittleEndianToNative8().

Referenced by write8().

Here is the call graph for this function:

Here is the caller graph for this function:

writeBitSwappedString()

void FileIO::writeBitSwappedString ( std::ofstream &  fout, std::string  writeString, size_t  outputSize = 0  )

inline

Definition at line 357 of file FileIO.h.

    {
        uint8_t nextChar = 0;
        size_t stringSize = writeString.size() + 1;
        if((0 == outputSize) || (outputSize >= stringSize)) {
            for(size_t i = 0 ; i < stringSize ; i++){
                nextChar = Endian::BitSwap8(writeString.at(i));
                fout.write(reinterpret_cast<char*>(&nextChar), 1);
            }
        } else {
            for(size_t i = 0 ; i < outputSize ; i++){
                nextChar = Endian::BitSwap8(writeString.at(i));
                fout.write(reinterpret_cast<char*>(&nextChar), 1);
            }
        }
        nextChar = 0;
        for( ; stringSize < outputSize ; stringSize++)
            fout.write(reinterpret_cast<char*>(&nextChar), 1);
    }

References Endian::BitSwap8(), and writeString().

Referenced by writeString().

Here is the call graph for this function:

Here is the caller graph for this function:

writeCharArray() [1/3]

void FileIO::writeCharArray ( std::ofstream &  fout, char *  writeCharArray, Endianness  e  )

inline

Definition at line 391 of file FileIO.h.

    {
        if(e == Endianness::BE_BS || e == Endianness::LE_BS)
            return FileIO::writeBitSwappedCharArray(fout, writeCharArray, 0);
        else
            return FileIO::writeCharArray(fout, writeCharArray, 0);
    }

References BE_BS, LE_BS, writeBitSwappedCharArray(), and writeCharArray().

Here is the call graph for this function:

writeCharArray() [2/3]

void FileIO::writeCharArray ( std::ofstream &  fout, char *  writeCharArray, size_t  outputSize, Endianness  e  )

inline

Definition at line 377 of file FileIO.h.

    {
        if(e == Endianness::BE_BS || e == Endianness::LE_BS)
            return FileIO::writeBitSwappedCharArray(fout, writeCharArray, outputSize);
        else
            return FileIO::writeCharArray(fout, writeCharArray, outputSize);
    }

References BE_BS, LE_BS, writeBitSwappedCharArray(), and writeCharArray().

Here is the call graph for this function:

writeCharArray() [3/3]

void FileIO::writeCharArray ( std::ofstream &  fout, char *  writeCharArray, size_t  outputSize = 0  )

inline

Definition at line 323 of file FileIO.h.

    {
        uint8_t nullChar = 0;
        size_t charArraySize = 1;
        for( ; (0 != writeCharArray[charArraySize-1] && charArraySize != outputSize); charArraySize++);
        fout.write(writeCharArray, charArraySize);
        for( ; charArraySize < outputSize ; charArraySize++)
            fout.write(reinterpret_cast<char*>(&nullChar), 1);
    }

Referenced by writeBitSwappedCharArray(), and writeCharArray().

Here is the caller graph for this function:

writeLittleEndian16()

void FileIO::writeLittleEndian16 ( std::ofstream &  fout, uint16_t  writeValue  )

inline

Definition at line 262 of file FileIO.h.

    {
        uint16_t writeValueLittleEndian = Endian::LittleEndianToNative16(writeValue);
        fout.write(reinterpret_cast<char*>(&writeValueLittleEndian), sizeof(writeValueLittleEndian));
    }

References Endian::LittleEndianToNative16().

Referenced by write16().

Here is the call graph for this function:

Here is the caller graph for this function:

writeLittleEndian32()

void FileIO::writeLittleEndian32 ( std::ofstream &  fout, uint32_t  writeValue  )

inline

Definition at line 257 of file FileIO.h.

    {
        uint32_t writeValueLittleEndian = Endian::LittleEndianToNative32(writeValue);
        fout.write(reinterpret_cast<char*>(&writeValueLittleEndian), sizeof(writeValueLittleEndian));
    }

References Endian::LittleEndianToNative32().

Referenced by write32().

Here is the call graph for this function:

Here is the caller graph for this function:

writeLittleEndian64()

void FileIO::writeLittleEndian64 ( std::ofstream &  fout, uint64_t  writeValue  )

inline

Definition at line 252 of file FileIO.h.

    {
        uint64_t writeValueLittleEndian = Endian::LittleEndianToNative64(writeValue);
        fout.write(reinterpret_cast<char*>(&writeValueLittleEndian), sizeof(writeValueLittleEndian));
    }

References Endian::LittleEndianToNative64().

Referenced by write64().

Here is the call graph for this function:

Here is the caller graph for this function:

writeLittleEndian8()

void FileIO::writeLittleEndian8 ( std::ofstream &  fout, uint8_t  writeValue  )

inline

Definition at line 267 of file FileIO.h.

    {
        uint8_t writeValueLittleEndian = Endian::LittleEndianToNative8(writeValue);
        fout.write(reinterpret_cast<char*>(&writeValueLittleEndian), sizeof(writeValueLittleEndian));
    }

References Endian::LittleEndianToNative8().

Referenced by write8().

Here is the call graph for this function:

Here is the caller graph for this function:

writeNative16()

void FileIO::writeNative16 ( std::ofstream &  fout, uint16_t  writeValue  )

inline

Definition at line 222 of file FileIO.h.

    {
        fout.write(reinterpret_cast<char*>(&writeValue), sizeof(writeValue));
    }

Referenced by write16().

Here is the caller graph for this function:

writeNative32()

void FileIO::writeNative32 ( std::ofstream &  fout, uint32_t  writeValue  )

inline

Definition at line 218 of file FileIO.h.

    {
        fout.write(reinterpret_cast<char*>(&writeValue), sizeof(writeValue));
    }

Referenced by write32().

Here is the caller graph for this function:

writeNative64()

void FileIO::writeNative64 ( std::ofstream &  fout, uint64_t  writeValue  )

inline

Definition at line 214 of file FileIO.h.

    {
        fout.write(reinterpret_cast<char*>(&writeValue), sizeof(writeValue));
    }

Referenced by write64().

Here is the caller graph for this function:

writeNative8()

void FileIO::writeNative8 ( std::ofstream &  fout, uint8_t  writeValue  )

inline

Definition at line 226 of file FileIO.h.

    {
        fout.write(reinterpret_cast<char*>(&writeValue), sizeof(writeValue));
    }

Referenced by write8().

Here is the caller graph for this function:

writeString() [1/3]

void FileIO::writeString ( std::ofstream &  fout, std::string  writeString, Endianness  e  )

inline

Definition at line 398 of file FileIO.h.

    {
        if(e == Endianness::BE_BS || e == Endianness::LE_BS)
            return FileIO::writeBitSwappedString(fout, writeString, 0);
        else
            return FileIO::writeString(fout, writeString, 0);
    }

References BE_BS, LE_BS, writeBitSwappedString(), and writeString().

Here is the call graph for this function:

writeString() [2/3]

void FileIO::writeString ( std::ofstream &  fout, std::string  writeString, size_t  outputSize, Endianness  e  )

inline

Definition at line 384 of file FileIO.h.

    {
        if(e == Endianness::BE_BS || e == Endianness::LE_BS)
            return FileIO::writeBitSwappedString(fout, writeString, outputSize);
        else
            return FileIO::writeString(fout, writeString, outputSize);
    }

References BE_BS, LE_BS, writeBitSwappedString(), and writeString().

Here is the call graph for this function:

writeString() [3/3]

void FileIO::writeString ( std::ofstream &  fout, std::string  writeString, size_t  outputSize = 0  )

inline

Definition at line 332 of file FileIO.h.

    {
        uint8_t nullChar = 0;
        size_t stringSize = writeString.size() + 1;
        if((0 == outputSize) || (outputSize >= stringSize))
            fout.write(writeString.c_str(), stringSize);
        else
            fout.write(writeString.c_str(), outputSize);
        for( ; stringSize < outputSize ; stringSize++)
            fout.write(reinterpret_cast<char*>(&nullChar), 1);
    }

Referenced by outputBITheader16bString(), writeBitSwappedString(), and writeString().

Here is the caller graph for this function: