GenRom.cpp

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#include <algorithm>

void printUsage()
{
    std::cout << "Usage: TrimFile -i <input_file> [-o <output_file>] -size <size> [-check] [-h]\n";
    std::cout << "Options:\n";
    std::cout << "  -i <input_file>       Specify the input file\n";
    std::cout << "  -o <output_file>      Specify the output file (default: overwrite input file)\n";
    std::cout << "  -size <size>          Specify the target size (e.g., 2048, 2048bit, 2048kb, 2048mb, 2048mbit)\n";
    std::cout << "  -check                Check if the file size is within the specified limit\n";
    std::cout << "  -h                    Display this help message\n";
}

long long parseSize(const std::string& sizeStr)
{
    long long size = 0;
    if (sizeStr.ends_with("bit"))
    {
        size = std::stoll(sizeStr.substr(0, sizeStr.size() - 3)) / 8;
    }
    else if (sizeStr.ends_with("byte"))
    {
        size = std::stoll(sizeStr.substr(0, sizeStr.size() - 4));
    }
    else if (sizeStr.ends_with("kb"))
    {
        size = std::stoll(sizeStr.substr(0, sizeStr.size() - 2)) * 1024;
    }
    else if (sizeStr.ends_with("mb"))
    {
        size = std::stoll(sizeStr.substr(0, sizeStr.size() - 2)) * 1024 * 1024;
    }
    else if (sizeStr.ends_with("mbit"))
    {
        size = std::stoll(sizeStr.substr(0, sizeStr.size() - 4)) * 1024 * 1024 / 8;
    }
    else
    {
        size = std::stoll(sizeStr); // Default to bytes
    }
    return size;
}

void trimFile(const std::string& inputFile, const std::string& outputFile, long long size, bool check)
{
    std::ifstream inFile(inputFile, std::ios::binary | std::ios::ate);
    if (!inFile)
    {
        std::cerr << "Error: Cannot open input file.\n";
        return;
    }

    long long fileSize = inFile.tellg();
    inFile.seekg(0, std::ios::beg);

    if (check)
    {
        if (fileSize > size)
        {
            std::cerr << "Error: File size exceeds specified size.\n";
        }
        else
        {
            std::cout << "File size is within the specified limit.\n";
        }
        return;
    }

    std::ofstream outFile(outputFile, std::ios::binary);
    if (!outFile)
    {
        std::cerr << "Error: Cannot open output file.\n";
        return;
    }

    char buffer[1024];
    long long bytesToWrite = std::min(size, fileSize);

    while (bytesToWrite > 0)
    {
        long long chunkSize = std::min(static_cast<long long>(sizeof(buffer)), bytesToWrite);
        inFile.read(buffer, chunkSize);
        outFile.write(buffer, chunkSize);
        bytesToWrite -= chunkSize;
    }

    std::cout << "File successfully trimmed to " << size << " bytes.\n";
}

int main(int argc, char* argv[])
{
    std::string inputFile, outputFile;
    std::string sizeStr;
    bool check = false;

    for (int i = 1; i < argc; ++i)
    {
        std::string arg = argv[i];
        if (arg == "-h")
        {
            printUsage();
            return 0;
        }
        else if (arg == "-i" && i + 1 < argc)
        {
            inputFile = argv[++i];
        }
        else if (arg == "-o" && i + 1 < argc)
        {
            outputFile = argv[++i];
        }
        else if (arg == "-size" && i + 1 < argc)
        {
            sizeStr = argv[++i];
        }
        else if (arg == "-check")
        {
            check = true;
        }
        else
        {
            printUsage();
            return 1;
        }
    }

    if (inputFile.empty() || sizeStr.empty())
    {
        printUsage();
        return 1;
    }

    if (outputFile.empty())
    {
        outputFile = inputFile;
    }

    long long size = parseSize(sizeStr);
    trimFile(inputFile, outputFile, size, check);

    return 0;
}