Is URL parser supposed to handle https://blah.com?

[estark37]

In walking through the URL parser state machine (https://url.spec.whatwg.org/#concept-basic-url-parser), it seems to me that on an input of "https://blah.com", the parser will return a URL whose scheme is "https" and whose other components (including hostname) are empty.

Here's the sequence of states I see happening:

1. scheme start state
2. scheme state
3. path or authority state
4. authority state
   => at this point we eat up all the characters, adding them to buffer one by one. After eating the last character, we exit step 11 (the state machine) all together (because c is EOF) and do not re-execute the authority state, meaning we never reach step 2.2 of authority state that continues on to host state.

Am I missing something and/or is this intentional?

[sleevi]

When you enter the authority state, you continue appending to buffer until you reach the EOF code point. However, once you reach the EOF codepoint in the authority state, you trigger Step 2 of the subalgorithm in https://url.spec.whatwg.org/#authority-state Step 2.2 decreases `pointer` by the length of `buffer` (Rewinding the processing) and transitions to the `host` state if the @ flag wasn't set, which it shouldn't be for this example.

[estark37]

@sleevi the authority state doesn't have a loop within it though. I read this algorithm as follows: after each execution of step 3 in the authority state, go back to the beginning of step 11 and switch on state again, re-entering the authority state, re-executing step 3, going back to beginning, etc. except after you've consumed the last character, you do not switch on state but instead carry on to step 12 ("If after a run pointer points to EOF code point, go to the next step.")

Maybe looping within the authority state is the intention (rather than switching on state after each completion of the steps within the state), but if so it's not clear to me from reading the algorithm.

[estark37]

Further, c/pointer are never incremented within the authority state, so as written we must return to the beginning of step 11 after each execution of the steps within the state in order to make progress.

[sleevi]

You increment after the EOF check, not before. You're correct that you
continue looping to the overall step 11, so /blah.com is:

pointer = /
/ is EOF? No. pointer++
c = *pointer // "b"
Authority parsing
  buffer += c // "b"
pointer = b  // This is the start of the next step 11
b is EOF? No. Pointer++
c = *pointer
Authority parsing
  buffer += c  // "bl"
...  // Keep repeating step 11
pointer = m
m is EOF? No. pointer++
c = *pointer  // EOF
Authority parsing
  c is EOF, @ is not set, so:
    pointer -= len(buffer)
    buffer = ""
    c = *pointer  // "b"
    Goto host state
Host parsing
   ...
pointer = l  // This is the start of the next step 11

That's what I meant by 2.2 of authority parsing; the EOF check happens
before the increment check, so the EOF should be parsed by the authority
parsing state

[estark37]

Ahh, I see now, thanks!