Bencode parser using stack - algorithm

Question

I am trying to use a stack-based approach to parse a bencoded string.
This link describes bencoding: https://www.bittorrent.org/beps/bep_0003.html
My psuedocode fails to handle the case where there are nested lists, for example, [1, [2]], and [[1, 2]] will both return [[1 ,2]], even when clearly the encoding is different, "li1eli2eee" versus "lli1ei2eee".
Here is my psuedocode thus far
input: string
output: map/list/integer/string in a bencoded data structure
first, tokenize the string into valid tokens
Valid tokens "d, l, [words], [numbers], e, s (virtual token)"
Strings are tokenized as 4:spam becomes "s spam e" with s being a virtual token
Eg. li1el4:spamee becomes [l i 1 e i 22 e l s spam e i 2 e e e]
Parsing:
make two stacks:
stack1
stack2
for token in tokens:
if stack is empty
return error
if the token isn’t an “e”
push token onto stack1
while the stack isn’t empty:
elem = pop off the stack
if elem is “i”
elem2 = pop elem off stack2 and check if it can be converted to an int
if not
return error
push elem2 onto stack2 again
elif elem is “d”
make a new dict
while stack2 isn’t empty:
key = pop off stack2
if stack2 is empty:
return error (because then we have an odd key value encoding)
value = pop off stack2
dict[key] = value
push dict onto stack2
elif elem is “l”
make a new list
while stack2 isn’t empty:
append pop off stack2 to l
push l onto stack2
elif elem is “s”
dont need to do anything :P
else
push elem onto stack2
if stack2 isn’t empty:
ret = pop the lone element off stack2
if stack2 isn’t empty:
return error
return ret

Answer 1

I don't quite follow the spec or the pseudocode, but it seems pretty straightforward to implement a subset of "Bencoding" to handle the two strings you've shown (lists and integers). Everything else is relatively trivial (dicts are the same as lists, more or less, and strings and other non-recursively defined data types are basically the same as ints) as far as I can tell.
My algorithm is as follows:
Make a stack and put an empty array into it.
For each index in the bencoded string:
If the current character is i, parse the integer and fast-forward the index to the e that closes the integer. Append the integer to the array at the top of the stack.
If the current character is l, push a new arr onto the stack.
If the current character is e, pop the stack and push the popped array onto the array below it (i.e. the new top).
Return the only element in the stack.
Here it is in JS:
const tinyBencodeDecode = s => {
const stack = [[]];
for (let i = 0; i < s.length; i++) {
if (s[i] === "i") {
for (var j = ++i; s[j] !== "e"; j++);
stack[stack.length-1].push(+s.slice(i, j));
i = j;
}
else if (s[i] === "l") {
stack.push([]);
}
else if (s[i] === "e") {
stack[stack.length-2].push(stack.pop());
}
}
return stack[0];
};
[
"i1ei2e", // => [1, 2]
"lli1ei2eee", // => [[1, 2]]
"li1eli2eee", // => [[1, [2]]]
// [44, [1, [23, 561, [], 1, [78]]], 4]
"i44eli1eli23ei561elei1eli78eeeei4e",
].forEach(e => console.log(JSON.stringify(tinyBencodeDecode(e))));
No error handling is performed and everything is assumed to be well-formed, but error handling doesn't impact the fundamental algorithm; it's just a matter of adding a bunch of conditionals to check the index, stack and string as you work.
Here's an (admittedly lazy) example of how you could support the 4 datatypes. Again, error handling is omitted. The idea is basically the same as above except more fussing is needed to determine whether we're building a dictionary or a list. Since null doesn't appear to be a valid key per the spec, I'm using it a placeholder to pair up value tokens with their corresponding key.
In both cases, minor adjustments will need to bee made if it turns out that bencoding only has a single root element (list or dictionary). In that case, s = "i42ei43e" would be invalid on the top level and we'd start with an empty stack.
const back = (a, n=1) => a[a.length-n];
const append = (stack, data) => {
if (Array.isArray(back(stack))) {
back(stack).push(data);
}
else {
const emptyKey = Object.entries(back(stack))
.find(([k, v]) => v === null);
if (emptyKey) {
back(stack)[emptyKey[0]] = data;
}
else {
back(stack)[data] = null;
}
}
};
const bencodeDecode = s => {
const stack = [[]];
for (let i = 0; i < s.length; i++) {
if (s[i] === "i") {
for (var j = ++i; s[j] !== "e"; j++);
append(stack, +s.slice(i, j));
i = j;
}
else if (/\d/.test(s[i])) {
for (var j = i; s[j] !== ":"; j++);
const num = +s.slice(i, j++);
append(stack, s.slice(j, j + num));
i = j + num - 1;
}
else if (s[i] === "l") {
stack.push([]);
}
else if (s[i] === "d") {
stack.push({});
}
else if (s[i] === "e") {
append(stack, stack.pop());
}
}
return stack[0];
};
[
"i1ei2e", // => [1, 2]
"lli1ei2eee", // => [[1, 2]]
"li1eli2eee", // => [[1, [2]]]
"li1e4:spamli2eee", // => [[1, "spam", [2]]]
// [[1, "spam", {"cow": "moo", "spam": {"eggs": [6, "rice"]}}, [2]]]
"li1e4:spamd3:cow3:moo4:spamd4:eggsli6e4:riceeeeli2eee",
// [44, [1, [23, 561, [], 1, [78]]], 4]
"i44eli1eli23ei561elei1eli78eeeei4e",
].forEach(e => console.log(JSON.stringify(bencodeDecode(e))));