107 lines
2.3 KiB
Go
107 lines
2.3 KiB
Go
package s19
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"fmt"
|
|
"os"
|
|
)
|
|
|
|
// writeSRecord creates a formatted S-record line
|
|
func writeSRecord(record SRecord) (string, error) {
|
|
var addressLength int
|
|
switch record.Type {
|
|
case "S1": // 2-byte address
|
|
addressLength = 2
|
|
case "S2": // 3-byte address
|
|
addressLength = 3
|
|
case "S3": // 4-byte address
|
|
addressLength = 4
|
|
case "S9": // Termination record with a 2-byte start address
|
|
addressLength = 2
|
|
default:
|
|
return "", fmt.Errorf("unsupported record type: %s", record.Type)
|
|
}
|
|
|
|
// Calculate the byte count: address bytes + data bytes + checksum byte
|
|
byteCount := 1 + addressLength + len(record.Data)
|
|
|
|
// Create the record string
|
|
addressFormat := fmt.Sprintf("%%0%dX", addressLength*2)
|
|
address := fmt.Sprintf(addressFormat, record.Address)
|
|
|
|
// Convert data to hexadecimal string
|
|
data := hex.EncodeToString(record.Data)
|
|
|
|
// Combine all components
|
|
body := fmt.Sprintf("%02X%s%s", byteCount, address, data)
|
|
|
|
// Compute checksum
|
|
checksum := computeChecksum(body)
|
|
|
|
// Construct the final S-record
|
|
return fmt.Sprintf("S%s%s%02X", record.Type[1:], body, checksum), nil
|
|
}
|
|
|
|
// computeChecksum calculates the checksum for an S-record
|
|
func computeChecksum(body string) byte {
|
|
sum := byte(0)
|
|
for i := 0; i < len(body); i += 2 {
|
|
value, _ := hex.DecodeString(body[i : i+2])
|
|
sum += value[0]
|
|
}
|
|
return ^sum
|
|
}
|
|
|
|
// writeS19File creates an S19 file with the provided records
|
|
func writeS19File(filename string, records []SRecord) error {
|
|
file, err := os.Create(filename)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer file.Close()
|
|
|
|
for _, record := range records {
|
|
line, err := writeSRecord(record)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = file.WriteString(line + "\n")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
// Example data to write
|
|
data := []byte("Hello, S19 world!")
|
|
|
|
// Create a list of records
|
|
records := []SRecord{
|
|
{
|
|
Type: "S1",
|
|
Address: 0x1000,
|
|
Data: data[:8], // First chunk
|
|
},
|
|
{
|
|
Type: "S1",
|
|
Address: 0x1008,
|
|
Data: data[8:], // Second chunk
|
|
},
|
|
{
|
|
Type: "S9",
|
|
Address: 0x1000, // Start address for the program
|
|
Data: nil,
|
|
},
|
|
}
|
|
|
|
// Write the records to a file
|
|
err := writeS19File("output.s19", records)
|
|
if err != nil {
|
|
fmt.Printf("Error writing S19 file: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println("S19 file written successfully.")
|
|
}
|