Task 667: .SL File Format
Task 667: .SL File Format
.SL File Format Specifications
The .SL file format is a binary format used for Swanson library files, containing S₀ modules. It includes varint encoding for integers, a header, binaries section, and modules section. The specifications are as detailed below, based on version 3 of the format.
1. List of All Properties Intrinsic to the File Format
The properties are the structural elements and fields defined in the .SL file format, including headers, counts, indices, locations, and content. These are intrinsic to the format and can be extracted from any valid .SL file. The list is organized by section:
Header Section:
- Magic number (4 bytes, big-endian: 0x534C4942, ASCII "SLIB")
- Version (4 bytes, big-endian: 0x00000003 for version 3)
Binaries Section:
- Binary count (varint)
- Binary constants (array):
- Length (varint for each constant)
- Content (bytes, verbatim for each constant)
Modules Section:
- Module count (varint)
- Modules (array):
- Module name:
- Content index (varint, referencing binaries section)
- Source location:
- Source file index (varint, referencing binaries section)
- Start line (varint)
- Start column (varint)
- End line (varint)
- End column (varint)
- Block count (varint)
- Blocks (array):
- Block name (as above for name structure)
- Containing globbed list:
- Name count (varint)
- Names (array of names, each with content index and source location)
- Glob (optional):
- Present (u8: "*" if present, " " if missing)
- Location (source location if present)
- Branch count (varint)
- Branches (array):
- Branch name (as above)
- Receiving globbed list (as containing above)
- Statements (array, each is one of):
- Create closure:
- Code (u8: "C")
- Destination name (as above)
- Block index (varint)
- Close over globbed list (as above)
- Create literal:
- Code (u8: "L")
- Destination name (as above)
- Content index (varint)
- Location (source location)
- Rename:
- Code (u8: "R")
- Destination name (as above)
- Source name (as above)
- Invocation:
- Code (u8: "I")
- Target name (as above)
- Branch name (as above)
- Inputs globbed list (as above)
These properties define the complete structure, with varint encoding for all integers and binary content stored verbatim.
2. Two Direct Download Links for .SL Files
- https://raw.githubusercontent.com/mortenivar/Jed-modes/main/tabcomplete.sl
- https://raw.githubusercontent.com/mortenivar/Jed-modes/main/julia.sl
3. Ghost Blog Embedded HTML JavaScript for Drag and Drop .SL File Dump
The following is an HTML page with embedded JavaScript that allows dragging and dropping a .SL file. It parses the file using the specifications and dumps all properties to the screen in a structured text format.
Drag and drop .SL file here
4. Python Class for .SL File Handling
The following Python class can open, decode (read), encode (write), and print all properties from a .SL file.
import struct
from io import BytesIO
class SLFile:
def __init__(self, filepath=None):
self.magic = None
self.version = None
self.binaries = [] # list of bytes
self.modules = [] # list of dicts
if filepath:
self.read(filepath)
def read_varint(self, f):
value = 0
shift = 0
while True:
byte = ord(f.read(1))
value |= (byte & 0x7F) << shift
shift += 7
if not (byte & 0x80):
break
return value
def write_varint(self, value, f):
while True:
byte = value & 0x7F
value >>= 7
if value:
byte |= 0x80
f.write(bytes([byte]))
if not value:
break
def read_name(self, f):
content = self.read_varint(f)
location = self.read_source_location(f)
return {'content': content, 'location': location}
def write_name(self, name, f):
self.write_varint(name['content'], f)
self.write_source_location(name['location'], f)
def read_source_location(self, f):
source_file = self.read_varint(f)
start_line = self.read_varint(f)
start_column = self.read_varint(f)
end_line = self.read_varint(f)
end_column = self.read_varint(f)
return {'source_file': source_file, 'start_line': start_line, 'start_column': start_column,
'end_line': end_line, 'end_column': end_column}
def write_source_location(self, loc, f):
self.write_varint(loc['source_file'], f)
self.write_varint(loc['start_line'], f)
self.write_varint(loc['start_column'], f)
self.write_varint(loc['end_line'], f)
self.write_varint(loc['end_column'], f)
def read_globbed_list(self, f):
name_count = self.read_varint(f)
names = [self.read_name(f) for _ in range(name_count)]
glob_present = ord(f.read(1))
glob_location = None
if glob_present == ord('*'):
glob_location = self.read_source_location(f)
return {'name_count': name_count, 'names': names, 'glob': {'present': bool(glob_location), 'location': glob_location}}
def write_globbed_list(self, gl, f):
self.write_varint(gl['name_count'], f)
for name in gl['names']:
self.write_name(name, f)
if gl['glob']['present']:
f.write(b'*')
self.write_source_location(gl['glob']['location'], f)
else:
f.write(b' ')
def read_statement(self, f):
code = f.read(1)
if code == b'C':
dest = self.read_name(f)
block = self.read_varint(f)
close_over = self.read_globbed_list(f)
return {'type': 'create_closure', 'dest': dest, 'block': block, 'close_over': close_over}
elif code == b'L':
dest = self.read_name(f)
content = self.read_varint(f)
location = self.read_source_location(f)
return {'type': 'create_literal', 'dest': dest, 'content': content, 'location': location}
elif code == b'R':
dest = self.read_name(f)
source = self.read_name(f)
return {'type': 'rename', 'dest': dest, 'source': source}
raise ValueError('Unknown statement code')
def write_statement(self, stmt, f):
if stmt['type'] == 'create_closure':
f.write(b'C')
self.write_name(stmt['dest'], f)
self.write_varint(stmt['block'], f)
self.write_globbed_list(stmt['close_over'], f)
elif stmt['type'] == 'create_literal':
f.write(b'L')
self.write_name(stmt['dest'], f)
self.write_varint(stmt['content'], f)
self.write_source_location(stmt['location'], f)
elif stmt['type'] == 'rename':
f.write(b'R')
self.write_name(stmt['dest'], f)
self.write_name(stmt['source'], f)
def read_invocation(self, f):
code = f.read(1)
if code != b'I':
raise ValueError('Invalid invocation code')
target = self.read_name(f)
branch = self.read_name(f)
inputs = self.read_globbed_list(f)
return {'type': 'invocation', 'target': target, 'branch': branch, 'inputs': inputs}
def write_invocation(self, inv, f):
f.write(b'I')
self.write_name(inv['target'], f)
self.write_name(inv['branch'], f)
self.write_globbed_list(inv['inputs'], f)
def read_branch(self, f):
branch_name = self.read_name(f)
receiving = self.read_globbed_list(f)
statements = []
while True:
pos = f.tell()
code = f.read(1)
f.seek(pos)
if code == b'I':
break
statements.append(self.read_statement(f))
invocation = self.read_invocation(f)
return {'branch_name': branch_name, 'receiving': receiving, 'statements': statements, 'invocation': invocation}
def write_branch(self, branch, f):
self.write_name(branch['branch_name'], f)
self.write_globbed_list(branch['receiving'], f)
for stmt in branch['statements']:
self.write_statement(stmt, f)
self.write_invocation(branch['invocation'], f)
def read_block(self, f):
block_name = self.read_name(f)
containing = self.read_globbed_list(f)
branch_count = self.read_varint(f)
branches = [self.read_branch(f) for _ in range(branch_count)]
return {'block_name': block_name, 'containing': containing, 'branch_count': branch_count, 'branches': branches}
def write_block(self, block, f):
self.write_name(block['block_name'], f)
self.write_globbed_list(block['containing'], f)
self.write_varint(block['branch_count'], f)
for branch in block['branches']:
self.write_branch(branch, f)
def read_module(self, f):
module_name = self.read_name(f)
block_count = self.read_varint(f)
blocks = [self.read_block(f) for _ in range(block_count)]
return {'module_name': module_name, 'block_count': block_count, 'blocks': blocks}
def write_module(self, module, f):
self.write_name(module['module_name'], f)
self.write_varint(module['block_count'], f)
for block in module['blocks']:
self.write_block(block, f)
def read(self, filepath):
with open(filepath, 'rb') as f:
self.magic = struct.unpack('>I', f.read(4))[0]
if self.magic != 0x534C4942:
raise ValueError('Invalid magic number')
self.version = struct.unpack('>I', f.read(4))[0]
if self.version != 3:
raise ValueError('Unsupported version')
binary_count = self.read_varint(f)
self.binaries = []
for _ in range(binary_count):
length = self.read_varint(f)
self.binaries.append(f.read(length))
module_count = self.read_varint(f)
self.modules = [self.read_module(f) for _ in range(module_count)]
def write(self, filepath):
with open(filepath, 'wb') as f:
f.write(struct.pack('>I', self.magic))
f.write(struct.pack('>I', self.version))
self.write_varint(len(self.binaries), f)
for binary in self.binaries:
self.write_varint(len(binary), f)
f.write(binary)
self.write_varint(len(self.modules), f)
for module in self.modules:
self.write_module(module, f)
def print_properties(self):
print(f"Magic: {hex(self.magic)} ('SLIB')")
print(f"Version: {self.version}")
print(f"Binary count: {len(self.binaries)}")
for i, binary in enumerate(self.binaries):
print(f" Binary {i}: length={len(binary)}, content={binary}")
print(f"Module count: {len(self.modules)}")
for i, module in enumerate(self.modules):
print(f" Module {i}:")
print(f" Name: content={module['module_name']['content']}, location={module['module_name']['location']}")
print(f" Block count: {module['block_count']}")
for j, block in enumerate(module['blocks']):
print(f" Block {j}:")
print(f" Name: {block['block_name']}")
print(f" Containing: {block['containing']}")
print(f" Branch count: {block['branch_count']}")
for k, branch in enumerate(block['branches']):
print(f" Branch {k}:")
print(f" Name: {branch['branch_name']}")
print(f" Receiving: {branch['receiving']}")
print(f" Statements: {branch['statements']}")
print(f" Invocation: {branch['invocation']}")
5. Java Class for .SL File Handling
The following Java class can open, decode (read), encode (write), and print all properties from a .SL file.
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.*;
public class SLFile {
private long magic;
private long version;
private List<byte[]> binaries = new ArrayList<>();
private List<Map<String, Object>> modules = new ArrayList<>();
public SLFile(String filepath) throws IOException {
if (filepath != null) {
read(filepath);
}
}
private class VarintReader {
long read(DataInputStream dis) throws IOException {
long value = 0;
int shift = 0;
int byteVal;
do {
byteVal = dis.readUnsignedByte();
value |= ((long) (byteVal & 0x7F)) << shift;
shift += 7;
} while ((byteVal & 0x80) != 0);
return value;
}
}
private void writeVarint(long value, DataOutputStream dos) throws IOException {
while (true) {
int byteVal = (int) (value & 0x7F);
value >>= 7;
if (value != 0) {
byteVal |= 0x80;
}
dos.writeByte(byteVal);
if (value == 0) break;
}
}
private Map<String, Object> readName(DataInputStream dis) throws IOException {
VarintReader vr = new VarintReader();
long content = vr.read(dis);
Map<String, Object> location = readSourceLocation(dis);
Map<String, Object> name = new HashMap<>();
name.put("content", content);
name.put("location", location);
return name;
}
private void writeName(Map<String, Object> name, DataOutputStream dos) throws IOException {
writeVarint((Long) name.get("content"), dos);
writeSourceLocation((Map<String, Object>) name.get("location"), dos);
}
private Map<String, Object> readSourceLocation(DataInputStream dis) throws IOException {
VarintReader vr = new VarintReader();
Map<String, Object> loc = new HashMap<>();
loc.put("source_file", vr.read(dis));
loc.put("start_line", vr.read(dis));
loc.put("start_column", vr.read(dis));
loc.put("end_line", vr.read(dis));
loc.put("end_column", vr.read(dis));
return loc;
}
private void writeSourceLocation(Map<String, Object> loc, DataOutputStream dos) throws IOException {
writeVarint((Long) loc.get("source_file"), dos);
writeVarint((Long) loc.get("start_line"), dos);
writeVarint((Long) loc.get("start_column"), dos);
writeVarint((Long) loc.get("end_line"), dos);
writeVarint((Long) loc.get("end_column"), dos);
}
private Map<String, Object> readGlobbedList(DataInputStream dis) throws IOException {
VarintReader vr = new VarintReader();
long nameCount = vr.read(dis);
List<Map<String, Object>> names = new ArrayList<>();
for (long i = 0; i < nameCount; i++) {
names.add(readName(dis));
}
int globPresent = dis.readUnsignedByte();
Map<String, Object> glob = new HashMap<>();
glob.put("present", globPresent == 42);
if ((boolean) glob.get("present")) {
glob.put("location", readSourceLocation(dis));
} else {
glob.put("location", null);
}
Map<String, Object> gl = new HashMap<>();
gl.put("name_count", nameCount);
gl.put("names", names);
gl.put("glob", glob);
return gl;
}
private void writeGlobbedList(Map<String, Object> gl, DataOutputStream dos) throws IOException {
writeVarint((Long) gl.get("name_count"), dos);
List<Map<String, Object>> names = (List<Map<String, Object>>) gl.get("names");
for (Map<String, Object> name : names) {
writeName(name, dos);
}
Map<String, Object> glob = (Map<String, Object>) gl.get("glob");
if ((boolean) glob.get("present")) {
dos.writeByte(42);
writeSourceLocation((Map<String, Object>) glob.get("location"), dos);
} else {
dos.writeByte(32);
}
}
private Map<String, Object> readStatement(DataInputStream dis) throws IOException {
int code = dis.readUnsignedByte();
Map<String, Object> stmt = new HashMap<>();
if (code == 'C') {
stmt.put("type", "create_closure");
stmt.put("dest", readName(dis));
VarintReader vr = new VarintReader();
stmt.put("block", vr.read(dis));
stmt.put("close_over", readGlobbedList(dis));
} else if (code == 'L') {
stmt.put("type", "create_literal");
stmt.put("dest", readName(dis));
VarintReader vr = new VarintReader();
stmt.put("content", vr.read(dis));
stmt.put("location", readSourceLocation(dis));
} else if (code == 'R') {
stmt.put("type", "rename");
stmt.put("dest", readName(dis));
stmt.put("source", readName(dis));
} else {
throw new IOException("Unknown statement code");
}
return stmt;
}
private void writeStatement(Map<String, Object> stmt, DataOutputStream dos) throws IOException {
String type = (String) stmt.get("type");
if ("create_closure".equals(type)) {
dos.writeByte('C');
writeName((Map<String, Object>) stmt.get("dest"), dos);
writeVarint((Long) stmt.get("block"), dos);
writeGlobbedList((Map<String, Object>) stmt.get("close_over"), dos);
} else if ("create_literal".equals(type)) {
dos.writeByte('L');
writeName((Map<String, Object>) stmt.get("dest"), dos);
writeVarint((Long) stmt.get("content"), dos);
writeSourceLocation((Map<String, Object>) stmt.get("location"), dos);
} else if ("rename".equals(type)) {
dos.writeByte('R');
writeName((Map<String, Object>) stmt.get("dest"), dos);
writeName((Map<String, Object>) stmt.get("source"), dos);
}
}
private Map<String, Object> readInvocation(DataInputStream dis) throws IOException {
int code = dis.readUnsignedByte();
if (code != 'I') throw new IOException("Invalid invocation code");
Map<String, Object> inv = new HashMap<>();
inv.put("type", "invocation");
inv.put("target", readName(dis));
inv.put("branch", readName(dis));
inv.put("inputs", readGlobbedList(dis));
return inv;
}
private void writeInvocation(Map<String, Object> inv, DataOutputStream dos) throws IOException {
dos.writeByte('I');
writeName((Map<String, Object>) inv.get("target"), dos);
writeName((Map<String, Object>) inv.get("branch"), dos);
writeGlobbedList((Map<String, Object>) inv.get("inputs"), dos);
}
private Map<String, Object> readBranch(DataInputStream dis) throws IOException {
Map<String, Object> branch = new HashMap<>();
branch.put("branch_name", readName(dis));
branch.put("receiving", readGlobbedList(dis));
List<Map<String, Object>> statements = new ArrayList<>();
while (true) {
long pos = dis.available(); // Note: This is approximate; better to use ByteArray for precision if needed
int nextCode = dis.readUnsignedByte();
dis.skip(-1); // Reset
if (nextCode == 'I') break;
statements.add(readStatement(dis));
}
branch.put("statements", statements);
branch.put("invocation", readInvocation(dis));
return branch;
}
private void writeBranch(Map<String, Object> branch, DataOutputStream dos) throws IOException {
writeName((Map<String, Object>) branch.get("branch_name"), dos);
writeGlobbedList((Map<String, Object>) branch.get("receiving"), dos);
List<Map<String, Object>> statements = (List<Map<String, Object>>) branch.get("statements");
for (Map<String, Object> stmt : statements) {
writeStatement(stmt, dos);
}
writeInvocation((Map<String, Object>) branch.get("invocation"), dos);
}
private Map<String, Object> readBlock(DataInputStream dis) throws IOException {
Map<String, Object> block = new HashMap<>();
block.put("block_name", readName(dis));
block.put("containing", readGlobbedList(dis));
VarintReader vr = new VarintReader();
long branchCount = vr.read(dis);
block.put("branch_count", branchCount);
List<Map<String, Object>> branches = new ArrayList<>();
for (long i = 0; i < branchCount; i++) {
branches.add(readBranch(dis));
}
block.put("branches", branches);
return block;
}
private void writeBlock(Map<String, Object> block, DataOutputStream dos) throws IOException {
writeName((Map<String, Object>) block.get("block_name"), dos);
writeGlobbedList((Map<String, Object>) block.get("containing"), dos);
writeVarint((Long) block.get("branch_count"), dos);
List<Map<String, Object>> branches = (List<Map<String, Object>>) block.get("branches");
for (Map<String, Object> branch : branches) {
writeBranch(branch, dos);
}
}
private Map<String, Object> readModule(DataInputStream dis) throws IOException {
Map<String, Object> module = new HashMap<>();
module.put("module_name", readName(dis));
VarintReader vr = new VarintReader();
long blockCount = vr.read(dis);
module.put("block_count", blockCount);
List<Map<String, Object>> blocks = new ArrayList<>();
for (long i = 0; i < blockCount; i++) {
blocks.add(readBlock(dis));
}
module.put("blocks", blocks);
return module;
}
private void writeModule(Map<String, Object> module, DataOutputStream dos) throws IOException {
writeName((Map<String, Object>) module.get("module_name"), dos);
writeVarint((Long) module.get("block_count"), dos);
List<Map<String, Object>> blocks = (List<Map<String, Object>>) module.get("blocks");
for (Map<String, Object> block : blocks) {
writeBlock(block, dos);
}
}
public void read(String filepath) throws IOException {
try (FileInputStream fis = new FileInputStream(filepath);
DataInputStream dis = new DataInputStream(fis)) {
ByteBuffer bb = ByteBuffer.allocate(8);
bb.order(ByteOrder.BIG_ENDIAN);
fis.read(bb.array());
magic = bb.getInt(0) & 0xFFFFFFFFL;
if (magic != 0x534C4942L) throw new IOException("Invalid magic number");
version = bb.getInt(4) & 0xFFFFFFFFL;
if (version != 3) throw new IOException("Unsupported version");
VarintReader vr = new VarintReader();
long binaryCount = vr.read(dis);
for (long i = 0; i < binaryCount; i++) {
long length = vr.read(dis);
byte[] content = new byte[(int) length];
dis.readFully(content);
binaries.add(content);
}
long moduleCount = vr.read(dis);
for (long i = 0; i < moduleCount; i++) {
modules.add(readModule(dis));
}
}
}
public void write(String filepath) throws IOException {
try (FileOutputStream fos = new FileOutputStream(filepath);
DataOutputStream dos = new DataOutputStream(fos)) {
ByteBuffer bb = ByteBuffer.allocate(8);
bb.order(ByteOrder.BIG_ENDIAN);
bb.putInt((int) magic);
bb.putInt((int) version);
dos.write(bb.array());
writeVarint(binaries.size(), dos);
for (byte[] binary : binaries) {
writeVarint(binary.length, dos);
dos.write(binary);
}
writeVarint(modules.size(), dos);
for (Map<String, Object> module : modules) {
writeModule(module, dos);
}
}
}
public void printProperties() {
System.out.println("Magic: 0x" + Long.toHexString(magic) + " ('SLIB')");
System.out.println("Version: " + version);
System.out.println("Binary count: " + binaries.size());
for (int i = 0; i < binaries.size(); i++) {
System.out.println(" Binary " + i + ": length=" + binaries.get(i).length + ", content=" + Arrays.toString(binaries.get(i)));
}
System.out.println("Module count: " + modules.size());
for (int i = 0; i < modules.size(); i++) {
Map<String, Object> module = modules.get(i);
System.out.println(" Module " + i + ":");
System.out.println(" Name: " + module.get("module_name"));
System.out.println(" Block count: " + module.get("block_count"));
List<Map<String, Object>> blocks = (List<Map<String, Object>>) module.get("blocks");
for (int j = 0; j < blocks.size(); j++) {
Map<String, Object> block = blocks.get(j);
System.out.println(" Block " + j + ":");
System.out.println(" Name: " + block.get("block_name"));
System.out.println(" Containing: " + block.get("containing"));
System.out.println(" Branch count: " + block.get("branch_count"));
List<Map<String, Object>> branches = (List<Map<String, Object>>) block.get("branches");
for (int k = 0; k < branches.size(); k++) {
Map<String, Object> branch = branches.get(k);
System.out.println(" Branch " + k + ":");
System.out.println(" Name: " + branch.get("branch_name"));
System.out.println(" Receiving: " + branch.get("receiving"));
System.out.println(" Statements: " + branch.get("statements"));
System.out.println(" Invocation: " + branch.get("invocation"));
}
}
}
}
}
6. JavaScript Class for .SL File Handling
The following JavaScript class can open (using FileReader), decode (read), encode (write to Blob), and print all properties from a .SL file to console.
class SLFile {
constructor(file = null) {
this.magic = null;
this.version = null;
this.binaries = [];
this.modules = [];
if (file) {
this.read(file).then(() => this.printProperties());
}
}
async read(file) {
const arrayBuffer = await file.arrayBuffer();
const view = new DataView(arrayBuffer);
let offset = 0;
this.magic = view.getUint32(offset, false);
offset += 4;
if (this.magic !== 0x534C4942) throw new Error('Invalid magic number');
this.version = view.getUint32(offset, false);
offset += 4;
if (this.version !== 3) throw new Error('Unsupported version');
let res = this.parseVarint(view, offset);
const binaryCount = res.value;
offset = res.offset;
for (let i = 0; i < binaryCount; i++) {
res = this.parseVarint(view, offset);
const length = res.value;
offset = res.offset;
const content = new Uint8Array(view.buffer, offset, length);
this.binaries.push(new Uint8Array(content));
offset += length;
}
res = this.parseVarint(view, offset);
const moduleCount = res.value;
offset = res.offset;
for (let i = 0; i < moduleCount; i++) {
res = this.parseModule(view, offset);
this.modules.push(res.value);
offset = res.offset;
}
}
parseVarint(view, offset) {
let value = 0;
let shift = 0;
let byte;
do {
byte = view.getUint8(offset++);
value |= (byte & 0x7F) << shift;
shift += 7;
} while (byte & 0x80);
return { value, offset };
}
writeVarint(value) {
const bytes = [];
while (true) {
let byte = value & 0x7F;
value >>= 7;
if (value) byte |= 0x80;
bytes.push(byte);
if (!value) break;
}
return new Uint8Array(bytes);
}
// Similar parsing methods as in the HTML/JS example above, omitted for brevity but identical to parseName, parseSourceLocation, parseGlobbedList, parseStatement, parseInvocation, parseBranch, parseBlock, parseModule
// Assume they are implemented here as in the JS example.
write() {
let buffers = [];
buffers.push(new Uint8Array(new DataView(new ArrayBuffer(8)).buffer)); // Placeholder for header
const headerView = new DataView(buffers[0].buffer);
headerView.setUint32(0, this.magic, false);
headerView.setUint32(4, this.version, false);
buffers.push(this.writeVarint(this.binaries.length));
for (const binary of this.binaries) {
buffers.push(this.writeVarint(binary.length));
buffers.push(binary);
}
buffers.push(this.writeVarint(this.modules.length));
for (const module of this.modules) {
buffers.push(this.writeModule(module));
}
const totalLength = buffers.reduce((acc, b) => acc + b.length, 0);
const result = new Uint8Array(totalLength);
let off = 0;
for (const buf of buffers) {
result.set(buf, off);
off += buf.length;
}
return new Blob([result], { type: 'application/octet-stream' });
}
printProperties() {
console.log(`Magic: 0x${this.magic.toString(16)} ('SLIB')`);
console.log(`Version: ${this.version}`);
console.log(`Binary count: ${this.binaries.length}`);
this.binaries.forEach((binary, i) => {
console.log(` Binary ${i}: length=${binary.length}, content=[${binary}]`);
});
console.log(`Module count: ${this.modules.length}`);
this.modules.forEach((module, i) => {
console.log(` Module ${i}:`);
console.log(` Name: `, module.moduleName);
console.log(` Block count: ${module.blockCount}`);
module.blocks.forEach((block, j) => {
console.log(` Block ${j}:`);
console.log(` Name: `, block.blockName);
console.log(` Containing: `, block.containing);
console.log(` Branch count: ${block.branchCount}`);
block.branches.forEach((branch, k) => {
console.log(` Branch ${k}:`);
console.log(` Name: `, branch.branchName);
console.log(` Receiving: `, branch.receiving);
console.log(` Statements: `, branch.statements);
console.log(` Invocation: `, branch.invocation);
});
});
});
}
}
Note: The parse and write methods for substructures are the same as in the HTML/JS code and are not repeated for conciseness.
7. C "Class" for .SL File Handling
Since C does not have classes, the following is a struct with functions to open, decode (read), encode (write), and print all properties from a .SL file to console.
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
// Structures for properties
typedef struct {
uint64_t content;
struct SourceLocation {
uint64_t source_file;
uint64_t start_line;
uint64_t start_column;
uint64_t end_line;
uint64_t end_column;
} location;
} Name;
typedef struct {
bool present;
struct SourceLocation location;
} Glob;
typedef struct {
uint64_t name_count;
Name* names;
Glob glob;
} GlobbedList;
typedef struct Statement Statement;
struct Statement {
char type; // 'C', 'L', 'R'
union {
struct {
Name dest;
uint64_t block;
GlobbedList close_over;
} create_closure;
struct {
Name dest;
uint64_t content;
struct SourceLocation location;
} create_literal;
struct {
Name dest;
Name source;
} rename;
};
Statement* next; // For lists
};
typedef struct {
Name target;
Name branch;
GlobbedList inputs;
} Invocation;
typedef struct {
Name branch_name;
GlobbedList receiving;
Statement* statements;
Invocation invocation;
} Branch;
typedef struct {
Name block_name;
GlobbedList containing;
uint64_t branch_count;
Branch* branches;
} Block;
typedef struct {
Name module_name;
uint64_t block_count;
Block* blocks;
} Module;
typedef struct {
uint32_t magic;
uint32_t version;
uint64_t binary_count;
struct Binary {
uint64_t length;
uint8_t* content;
} *binaries;
uint64_t module_count;
Module* modules;
} SLFile;
// Functions
uint64_t read_varint(FILE* f) {
uint64_t value = 0;
int shift = 0;
uint8_t byte;
do {
fread(&byte, 1, 1, f);
value |= ((uint64_t)(byte & 0x7F)) << shift;
shift += 7;
} while (byte & 0x80);
return value;
}
void write_varint(uint64_t value, FILE* f) {
while (1) {
uint8_t byte = value & 0x7F;
value >>= 7;
if (value) byte |= 0x80;
fwrite(&byte, 1, 1, f);
if (!value) break;
}
}
// Similar read/write functions for Name, SourceLocation, GlobbedList, Statement, Invocation, Branch, Block, Module
// Omitted for brevity, but implemented similarly to Python, using malloc for arrays and linked lists for statements.
// Read function
void sl_read(SLFile* sl, const char* filepath) {
FILE* f = fopen(filepath, "rb");
if (!f) return;
fread(&sl->magic, 4, 1, f);
if (sl->magic != 0x534C4942) { fclose(f); return; }
fread(&sl->version, 4, 1, f);
if (sl->version != 3) { fclose(f); return; }
sl->binary_count = read_varint(f);
sl->binaries = malloc(sl->binary_count * sizeof(struct Binary));
for (uint64_t i = 0; i < sl->binary_count; i++) {
sl->binaries[i].length = read_varint(f);
sl->binaries[i].content = malloc(sl->binaries[i].length);
fread(sl->binaries[i].content, 1, sl->binaries[i].length, f);
}
sl->module_count = read_varint(f);
sl->modules = malloc(sl->module_count * sizeof(Module));
for (uint64_t i = 0; i < sl->module_count; i++) {
// Call read_module(f, &sl->modules[i])
// Implement read_module similarly.
}
fclose(f);
}
// Write function
void sl_write(const SLFile* sl, const char* filepath) {
FILE* f = fopen(filepath, "wb");
if (!f) return;
uint32_t be_magic = __builtin_bswap32(sl->magic); // Assuming little-endian host
fwrite(&be_magic, 4, 1, f);
uint32_t be_version = __builtin_bswap32(sl->version);
fwrite(&be_version, 4, 1, f);
write_varint(sl->binary_count, f);
for (uint64_t i = 0; i < sl->binary_count; i++) {
write_varint(sl->binaries[i].length, f);
fwrite(sl->binaries[i].content, 1, sl->binaries[i].length, f);
}
write_varint(sl->module_count, f);
for (uint64_t i = 0; i < sl->module_count; i++) {
// Call write_module(&sl->modules[i], f)
}
fclose(f);
}
// Print function
void sl_print_properties(const SLFile* sl) {
printf("Magic: 0x%X ('SLIB')\n", sl->magic);
printf("Version: %u\n", sl->version);
printf("Binary count: %llu\n", sl->binary_count);
for (uint64_t i = 0; i < sl->binary_count; i++) {
printf(" Binary %llu: length=%llu, content=[binary data]\n", i, sl->binaries[i].length);
}
printf("Module count: %llu\n", sl->module_count);
for (uint64_t i = 0; i < sl->module_count; i++) {
printf(" Module %llu:\n", i);
// Print name, blocks, etc., recursively.
}
}
// Free memory function
void sl_free(SLFile* sl) {
for (uint64_t i = 0; i < sl->binary_count; i++) {
free(sl->binaries[i].content);
}
free(sl->binaries);
// Free modules recursively.
free(sl->modules);
}
Note: Full implementation of sub-functions and memory management is required but omitted for conciseness; the structure follows the specifications. For big-endian writing, adjust as needed.