Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-05 03:21:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

[wpiutil] Remove LEB128 (#7628)

Browse Source 
This was only used for NT3.
This commit is contained in:
Peter Johnson
2025-01-03 07:13:49 -08:00
committed by GitHub
parent 1240ee1bf4
commit 12a1475ee4
3 changed files with 0 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
wpiutil/src/main/native/cpp/leb128.cpp
View File

@@ -1,118 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include "wpi/leb128.h"
#include "wpi/SpanExtras.h"
#include "wpi/raw_istream.h"
#include "wpi/raw_ostream.h"
namespace wpi {
uint64_t SizeUleb128(uint64_t val) {
size_t count = 0;
do {
val >>= 7;
++count;
} while (val != 0);
return count;
}
uint64_t WriteUleb128(SmallVectorImpl<char>& dest, uint64_t val) {
size_t count = 0;
do {
uint8_t byte = val & 0x7f;
val >>= 7;
if (val != 0) {
byte |= 0x80; // mark this byte to show that more bytes will follow
}
dest.push_back(byte);
count++;
} while (val != 0);
return count;
}
void WriteUleb128(raw_ostream& os, uint64_t val) {
do {
uint8_t byte = val & 0x7f;
val >>= 7;
if (val != 0) {
byte |= 0x80; // mark this byte to show that more bytes will follow
}
os << byte;
} while (val != 0);
}
uint64_t ReadUleb128(const char* addr, uint64_t* ret) {
uint64_t result = 0;
int shift = 0;
size_t count = 0;
while (1) {
unsigned char byte = *reinterpret_cast<const unsigned char*>(addr);
addr++;
count++;
result |= (byte & 0x7fULL) << shift;
shift += 7;
if (!(byte & 0x80)) {
break;
}
}
*ret = result;
return count;
}
bool ReadUleb128(raw_istream& is, uint64_t* ret) {
uint64_t result = 0;
int shift = 0;
while (1) {
unsigned char byte;
is.read(reinterpret_cast<char*>(&byte), 1);
if (is.has_error()) {
return false;
}
result |= (byte & 0x7fULL) << shift;
shift += 7;
if (!(byte & 0x80)) {
break;
}
}
*ret = result;
return true;
}
std::optional<uint64_t> Uleb128Reader::ReadOne(std::span<const uint8_t>* in) {
while (!in->empty()) {
uint8_t byte = in->front();
*in = wpi::drop_front(*in);
m_result |= (byte & 0x7fULL) << m_shift;
m_shift += 7;
if (!(byte & 0x80)) {
uint64_t result = m_result;
m_result = 0;
m_shift = 0;
return result;
}
}
return std::nullopt;
}
} // namespace wpi

111
wpiutil/src/main/native/include/wpi/leb128.h
View File

@@ -1,111 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#ifndef WPIUTIL_WPI_LEB128_H_
#define WPIUTIL_WPI_LEB128_H_
#include <stdint.h>
#include <optional>
#include <span>
namespace wpi {
template <typename T>
class SmallVectorImpl;
class raw_istream;
class raw_ostream;
/**
* Get size of unsigned LEB128 data.
*
* Determine the number of bytes required to encode an unsigned LEB128 datum.
* The algorithm is taken from Appendix C of the DWARF 3 spec. For information
* on the encodings refer to section "7.6 - Variable Length Data". Return
* the number of bytes required.
*
* @param val LEB128 data.
*/
uint64_t SizeUleb128(uint64_t val);
/**
* Write unsigned LEB128 data.
*
* Encode an unsigned LEB128 encoded datum. The algorithm is taken
* from Appendix C of the DWARF 3 spec. For information on the
* encodings refer to section "7.6 - Variable Length Data". Return
* the number of bytes written.
*
* @param dest The address where the ULEB128 data is to be stored.
* @param val Value to be stored.
*/
uint64_t WriteUleb128(SmallVectorImpl<char>& dest, uint64_t val);
/**
* Write unsigned LEB128 data.
*
* Encode an unsigned LEB128 encoded datum. The algorithm is taken
* from Appendix C of the DWARF 3 spec. For information on the
* encodings refer to section "7.6 - Variable Length Data".
*
* @param os Output stream.
* @param val Value to be stored.
*/
void WriteUleb128(raw_ostream& os, uint64_t val);
/**
* Read unsigned LEB128 data.
*
* Decode an unsigned LEB128 encoded datum. The algorithm is taken
* from Appendix C of the DWARF 3 spec. For information on the
* encodings refer to section "7.6 - Variable Length Data". Return
* the number of bytes read.
*
* @param addr The address where the ULEB128 data is stored.
* @param ret Address to store the result.
*/
uint64_t ReadUleb128(const char* addr, uint64_t* ret);
/**
* Read unsigned LEB128 data from a stream.
*
* Decode an unsigned LEB128 encoded datum. The algorithm is taken
* from Appendix C of the DWARF 3 spec. For information on the
* encodings refer to section "7.6 - Variable Length Data". Return
* false on stream error, true on success.
*
* @param is The input stream where the ULEB128 data is to be read from.
* @param ret Address to store the result.
*/
bool ReadUleb128(raw_istream& is, uint64_t* ret);
/**
* Unsigned LEB128 streaming reader.
*
* Decode an unsigned LEB128 encoded datum. The algorithm is taken
* from Appendix C of the DWARF 3 spec. For information on the
* encodings refer to section "7.6 - Variable Length Data".
*/
class Uleb128Reader {
public:
/**
* Decode a single ULEB128 value. Returns after a single ULEB128 value has
* been read or insufficient input (call in a loop to get multiple values).
* If a value is returned, internal state is reset so it's safe to immediately
* call this function again to decode another value.
*
* @param in Input data; modified as data is consumed (any unconsumed data
* is left when function returns).
* @return value (in std::optional)
*/
std::optional<uint64_t> ReadOne(std::span<const uint8_t>* in);
private:
uint64_t m_result = 0;
int m_shift = 0;
};
} // namespace wpi
#endif // WPIUTIL_WPI_LEB128_H_