1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
const std = @import("std");
const print = std.debug.print;
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const Thread = std.Thread;
const Mutex = std.Thread.Mutex;
const parser = @import("parser.zig");
const Command = parser.Command;
const eval = @import("eval.zig");
const CommandStatus = eval.CommandStatus;
const paths = @import("paths.zig");
const convertTo83 = paths.convertTo83;
const STDOUT_BUFFER_SIZE: usize = 1024;
const STDERR_BUFFER_SIZE: usize = 1024;
fn formatPath(allocator: Allocator, path: []const u8) ![]const u8 {
// Normalize separators and case first
var normalized = ArrayList(u8).init(allocator);
defer normalized.deinit();
for (path) |ch| {
if (ch == '/') {
try normalized.append('\\');
} else {
try normalized.append(std.ascii.toUpper(ch));
}
}
// Extract drive letter if present (e.g., "C:")
var idx: usize = 0;
var has_drive = false;
var drive_letter: u8 = 'C';
if (normalized.items.len >= 2 and normalized.items[1] == ':') {
has_drive = true;
drive_letter = normalized.items[0];
idx = 2;
}
// Remember if the path is absolute after the drive (leading backslash)
var starts_with_backslash = false;
if (idx < normalized.items.len and normalized.items[idx] == '\\') {
starts_with_backslash = true;
// Skip the first leading backslash to avoid creating an empty component
idx += 1;
}
// Build result with components converted to 8.3
var result = ArrayList(u8).init(allocator);
defer result.deinit();
// If absolute, start with a backslash (after potential drive prefix)
if (starts_with_backslash) {
try result.append('\\');
}
var it = std.mem.splitScalar(u8, normalized.items[idx..], '\\');
var first_component = true;
while (it.next()) |component| {
if (component.len == 0) continue;
if (!first_component and result.items.len > 0 and result.items[result.items.len - 1] != '\\') {
try result.append('\\');
}
first_component = false;
const short_name = try convertTo83(allocator, component);
defer allocator.free(short_name.name);
defer allocator.free(short_name.ext);
try result.appendSlice(short_name.name);
if (short_name.ext.len > 0) {
try result.append('.');
try result.appendSlice(short_name.ext);
}
}
// Prepend drive if present or add default C:
var final_buf = ArrayList(u8).init(allocator);
defer final_buf.deinit();
if (has_drive) {
try final_buf.append(drive_letter);
try final_buf.append(':');
if (result.items.len > 0 and result.items[0] != '\\') {
try final_buf.append('\\');
}
try final_buf.appendSlice(result.items);
} else {
// No drive: default to C:
try final_buf.appendSlice("C:");
if (result.items.len > 0 and result.items[0] != '\\') {
try final_buf.append('\\');
}
try final_buf.appendSlice(result.items);
}
return allocator.dupe(u8, final_buf.items);
}
fn parseAndExecute(input: []const u8, allocator: Allocator) !CommandStatus {
var command = parser.parse(input, allocator) catch |err| {
switch (err) {
error.ExpectedWord, error.UnexpectedToken => {
return CommandStatus{ .Code = 1 };
},
else => return err,
}
};
defer command.deinit(allocator);
return try eval.executeCommand(command, allocator);
}
fn readLine(allocator: Allocator, prompt_text: []const u8) !?[]const u8 {
const stdin = std.io.getStdIn().reader();
print("{s}", .{prompt_text});
if (try stdin.readUntilDelimiterOrEofAlloc(allocator, '\n', 4096)) |input| {
// Remove trailing \r on Windows
if (input.len > 0 and input[input.len - 1] == '\r') {
return input[0 .. input.len - 1];
}
return input;
}
return null;
}
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
print("Starting MB-DOSE...\n\n", .{});
print("HIMEM is testing extended memory...done.\n\n", .{});
const prompt_spec = "$p$g ";
while (true) {
const cwd = std.fs.cwd().realpathAlloc(allocator, ".") catch |err| switch (err) {
error.FileNotFound => "C:\\",
else => return err,
};
defer allocator.free(cwd);
const full_cwd = try formatPath(allocator, cwd);
defer allocator.free(full_cwd);
const interpolated_prompt = try std.mem.replaceOwned(u8, allocator, prompt_spec, "$p", full_cwd);
defer allocator.free(interpolated_prompt);
const final_prompt = try std.mem.replaceOwned(u8, allocator, interpolated_prompt, "$g", ">");
defer allocator.free(final_prompt);
if (try readLine(allocator, final_prompt)) |line| {
defer allocator.free(line);
const command_result = parseAndExecute(line, allocator) catch |err| {
switch (err) {
error.ExpectedWord, error.UnexpectedToken => {
print("Bad command or file name\n", .{});
continue;
},
else => return err,
}
};
switch (command_result) {
.ExitShell => break,
.Code => |_| {},
}
} else {
break; // EOF
}
}
}
|
