srec.h

// Copyright 2018-2019 Delft University of Technology
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <cstdint>
#include <stdexcept>
#include <cstring>
#include <ostream>
#include <vector>
#include <memory>
#include <iostream>
#include <optional>
#include <string>
#include <sstream>
#include <iomanip>
 
namespace fletchgen::srec {
 
class Record {
 public:
  static constexpr size_t MAX_DATA_BYTES = 32;
 
  enum Type {
    HEADER = 0,
    DATA16 = 1,
    DATA24 = 2,
    DATA32 = 3,
    RESERVED = 4,
    COUNT16 = 5,
    COUNT24 = 6,
    TERM32 = 7,
    TERM24 = 8,
    TERM16 = 9
  };
 
  Record(const Record &rec) : Record(rec.type_, rec.address_, rec.data_, rec.size_) {}
 
  Record(Type type, uint32_t address, const uint8_t *data, size_t size);
 
  ~Record();
 
  static std::optional<Record> FromString(const std::string &line);
 
  static Record Header(const std::string &header_str = "HDR", uint16_t address = 0);
 
  template<uint32_t S>
  static Record Data(uint32_t srec_address, const uint8_t *data, size_t size) {
    switch (S) {
      case 16:return Record(DATA16, srec_address, data, size);
      case 24:return Record(DATA24, srec_address, data, size);
      case 32:return Record(DATA32, srec_address, data, size);
      default:throw std::domain_error("SREC data records can only have 16, 24 or 32-bit address fields.");
    }
  }
 
  std::string ToString(bool line_feed = false);
 
  [[nodiscard]] inline uint32_t address() const { return address_; }
  [[nodiscard]] inline size_t size() const { return size_; }
  [[nodiscard]] inline uint8_t *data() const { return data_; }
 
 private:
  Type type_ = RESERVED;
  size_t size_ = 0;
  uint32_t address_ = 0;
  uint8_t *data_ = nullptr;
 
  int address_width();
  uint8_t byte_count();
  uint8_t checksum();
};
 
inline void PutHex(std::stringstream &stream, uint32_t val, int characters = 2) {
  stream << std::uppercase << std::hex << std::setfill('0') << std::setw(characters) << val;
}
 
struct File {
  File() = default;
 
  File(uint32_t start_address, const uint8_t *data, size_t size, const std::string &header_str = "HDR");
 
  explicit File(std::istream *input);
 
  void write(std::ostream *output);
 
  void ToBuffer(uint8_t **buffer, size_t *size);
 
  std::vector<Record> records;
};
 
}  // namespace fletchgen::srec