ezhttp

Search uses release 0.22.0.0 · 909 definitions

Releases (1)

0.22.0.0 indexed

Definitions (909)

src/http.bend

def chunks.ended.sizea chunk of size n: the last one when n is 0
def chunks.ended.hexa chunk header: a size that is not hex ends the read (the parse rejects it)
def chunks.ended.ata chunk header that has arrived, or not yet
def chunks.endedwhether a chunked body has reached the end of its last chunk
def whole.ofwhether a body has all arrived under its framing
def whole.stepa head that is interim: whole when what follows is; else whole under the framing it gives
def whole.ata response whose head has ended, or not yet
def whole.gothe heads in turn, at most `fuel` of them
def wholewhether the text received so far is a whole response to a request with this method (RFC 9112 §6.3), interim 1xx heads read past (RFC 9110 §15.2); a response framed by the close never is
def status.emptya 1xx, 204 or 304 response has no body (RFC 9110 §6.4.1)
def head.barea head that has no body: its status and fields (RFC 9110 §6.4.1)
def head.final.ofa final head's plan once it is known whether it has a body
def head.finala final head's plan: no body for a reply to HEAD or a 1xx, 204 or 304 status (RFC 9110 §6.4.1, §9.3.2), else as head.plan frames it
def interim.skip.ofan interim head is skipped when anything follows it
def interim.skipan interim head is skipped when more text follows it
def parse.to.barethe final head with no body: its status and fields, an empty body
def parse.to.finalthe final head: with no body, or framed as parse frames it
def parse.to.stepan interim head is skipped, any other is the final one
def parse.to.ata head that has ended, or the reason it has not
def parse.to.gothe heads in turn, at most `fuel` of them
def parse.tothe response to a request with this method (RFC 9112 §6.3): interim 1xx heads skipped, and no body for HEAD or a 1xx, 204 or 304 final status
type Skipbytes of UTF-8 walked off the front of a string: all of it, with this many still owed, or a stop at the first character that does not fit in what was left, with what was left and the text from that character on
def octs.skip.stepone step of the skip: a character wider than what is left stops it
def octs.skipwalk n bytes of UTF-8 off a string, as octs.drop does, saying how it ended
type Walkwhere a chunked body's walk stands: ended; waiting at a chunk header (or the last chunk's trailer) that has not all arrived; inside a chunk's data with octets still owed; or at the end of a chunk's data, at what should be its CRLF.
def walk.crlfa chunk's data skipped: whether its CRLF has arrived, and on to the next chunk header when it has
def walk.dataa chunk's data: all of what arrived, with octets still owed, or its end
def walk.trailthe last chunk: ended once its trailer section has
def walk.sizea chunk of size n: the last one when n is 0
def walk.hexa chunk header: a size that is not hex ends the walk (the parse rejects it)
def walk.ata chunk header that has arrived, or not yet
def walkthe walk of chunks.ended from the chunk header at the front of a text
def walk.donewhether the walk has ended
def walk.morethe walk once m more characters, b, have arrived
type Hearwhere a response stands: no final head yet (with the text from the head being read on, and the fuel whole.go would have there); no body, so whole; framed by the close, so never whole; sized, with the octets that have arrived; or chunked, with its walk
def hear.bodya final head's body under its framing
def hear.stepan interim head: on to the next; a final one: its body
def hear.ata head that has ended, or not yet
def hear.gothe heads in turn, as whole.go reads them
def hear.ofwhere a response to a request with this method stands, read from the whole text received so far
def hear.donewhether the response has all arrived
def hear.morewhere a response stands once more text, b, has arrived
def walk.countswhether a walk can be advanced by a count of octets alone: inside a chunk's data that still owes at least that many
def walk.more.na walk advanced by m octets it does not look at (walk.counts says when that is walk.more)
def hear.countswhether a state can be advanced by a count of octets alone, without their text: a whole response, a body framed by the close or by Content-Length, or a chunk's data that still owes at least that many (SPEC.md HTTP-CLI-6)
def hear.more.na state advanced by m octets it does not look at (hear.counts says when that is hear.more)
def phrase.chop.ata reason phrase with the CR its line ended with removed; a reason-phrase itself holds no CR (RFC 9112 §4)
def phrase.chopthe text of a reason phrase, a final CR removed
def phrase.codewhat follows the status code's SP: the reason phrase; none without that SP
def phrase.afterwhat follows the version's SP: the status code, an SP and the reason
def phrase.linea status line's reason phrase (RFC 9112 §4: HTTP-version SP status-code SP [ reason-phrase ]), empty when the line has fewer than two SPs
def phrase.to.stepan interim head is skipped, any other gives the reason on its first line
def phrase.to.ata head that has ended, or none
def phrase.to.gothe heads in turn, at most `fuel` of them
def phrase.tothe reason phrase of the head parse.to stops at: interim 1xx heads with text after them skipped, empty when no head ends

src/packed.bend

type Gota response read off its octets: torn, or its status, its header fields and reason phrase as octet text, and its body's octets
type Partsa chunked body's octets so far, newest first, or why it was torn
def packed.text.ofa slice's copy as text, the buffer kept
def packed.textn octets from `at` as text (a head or a chunk-size line), the buffer kept
def packed.copyn octets from `at`, the buffer dropped
def packed.chunk.takea chunk's octets copied out, then on to the chunk-size line after its CRLF
def packed.chunk.ready.isa chunk of k octets from d, ready when its CRLF follows them
def packed.chunk.readya chunk of k octets from d whose CRLF has been looked for (chunks.ready)
def packed.chunk.dataa chunk of n octets from d: its octets must all be there, and a CRLF after them
def packed.chunk.sizewhat a chunk-size line says, acted on with the octets after it
def packed.chunk.linea chunk-size line read, its octets after its CRLF
def packed.chunk.ata chunk-size line that ends at i, or none ends: the body ends there
def packed.chunksthe chunks from the chunk-size line at p, at most `fuel` of them
def packed.chunkeda chunked body's octets in order, or why it was torn
def packed.sizeda body framed by Content-Length: torn when fewer octets arrived
def packed.bodythe octets after the final head, as its framing says
def packed.finalthe final head's plan carried out on the octets after it
def packed.stepan interim head is skipped, any other is the final one
def packed.head.texta head read as text, and the octets after its blank line from q
def packed.heada head that ends at i, or none ends
def packed.headsthe heads in turn from p, at most `fuel` of them
def packed.reply.ofthe response to a request with this method, its octets counted
def packed.replythe response to a request with this method, read off its octets as parse.to reads its text (SPEC.md HTTP-CLI-9, HTTP-CLI-15, HTTP-TRUST-9)

src/pct.bend

def unreservedRFC 3986 §2.3 unreserved: ALPHA / DIGIT / "-" / "." / "_" / "~"
def safea character a form writes as itself: unreserved, or "/" when `slash` (the path form) keeps it
def hexone hex digit, upper case: 0-9 then A-F ('A' is 55 + 10)
def pctbytes as %XX triples, high nibble first, followed by `rest`
def conta continuation byte: 10xxxxxx from the six bits at `shift`
def utf8.fourfour bytes: U+10000 to U+10FFFF
def utf8.threethree bytes below U+10000, else four
def utf8.twotwo bytes below U+0800, else more
def utf8.oneone byte below U+0080, else more
def utf8the UTF-8 bytes of one code point, in order (RFC 3629 §3)
def one.ofone character, once it is known whether the form keeps it
def oneone character as the form writes it, followed by `rest`
def quotea string as the form writes it: each character in turn

src/qs.bend

def Kva name and a value, as a query field or a cookie: a reusable pair, so a list of them can be looked up more than once
type Tokone piece of a string being decoded: a byte of an ASCII run, or a character outside ASCII, which is kept as it is and ends the run
type Escwhere the decoding stands: in plain text, after `%`, or after `%` and one hex digit (kept)
def tok.hexwhether a character is a hex digit (`0`-`9`, `A`-`F`, `a`-`f`)
def tok.bytethe byte a plain ASCII character stands for: `+` is a space when `plus`
def tok.asciia plain ASCII character: `%` opens an escape, any other is its byte
def tok.widea plain character once it is known whether it is outside ASCII
def tok.plaina character in plain text
def tok.pcta character after `%`: a hex digit is kept, anything else leaves the `%` as written