Golang’s solution to implement Redis protocol parser

$3\r\nSET\r\n

$4a\r\nb

*2
$3
foo
$3
bar

*3
$3
SET
$3
key
$5
value

*3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n

*3  
$3
SET
$4
a\r\nb 
$7
myvalue

*3  
$3
SET
$4
a  // Wrong branchb // Wrong branch$7
myvalue

msg = make([]byte, 4 + 2) // Body length 4 + line break length 2_, err = (reader, msg)

// Payload stores  or error
type Payload struct {
	Data 
	Err  error
}

// ParseStream reads the data and returns the result to the caller through the channel// The streaming interface is suitable for client/server usefunc ParseStream(reader ) <-chan *Payload {
	ch := make(chan *Payload)
	go parse0(reader, ch)
	return ch
}

// ParseOne parses []byte and returnsfunc ParseOne(data []byte) (, error) {
	ch := make(chan *Payload)
	reader := (data)
	go parse0(reader, ch)
	payload := <-ch // parse0 will close the channel
	if payload == nil {
		return nil, ("no reply")
	}
	return , 
}

func parse0(reader , ch chan<- *Payload) {
    // Initialize the read state    readingMultiLine := false
    expectedArgsCount := 0
    var args [][]byte
    var bulkLen int64
    for {
        // In the above we mentioned that RESP is based on behavioral units        // Because lines are divided into simple strings and binary-safe BulkString, we need to encapsulate a readLine function to be compatible        line, err = readLine(reader, bulkLen)
        if err != nil { 
            // Handle errors            return
        }
        // Next we parse the line we just read        // We simply divide Reply into two categories:        // Single line: StatusReply, IntReply, ErrorReply        // Multi-line: BulkReply, MultiBulkReply
        if !readingMultiLine {
            if isMulitBulkHeader(line) {
                // We received the first line from MulitBulkReply                // Get the number of BulkStrings in MulitBulkReply                expectedArgsCount = parseMulitBulkHeader(line)
                // Wait for MulitBulkReply to follow up                readingMultiLine = true
            } else if isBulkHeader(line) {
                // We received the first line of BulkReply                // Get the length of the second line of BulkReply, and tell the readLine function the length of the BulkString next line through bulkLen                bulkLen = parseBulkHeader()
                // There are 1 BulkString in this Reply                expectedArgsCount = 1 
                // Wait for BulkReply to follow up                readingMultiLine = true
            } else {
                // Handle single lines such as StatusReply, IntReply, ErrorReply, etc. Reply                reply := parseSingleLineReply(line)
                // Return the result via ch                emitReply(ch)
            }
        } else {
            // Entering this branch means we are waiting for the follow-up line of MulitBulkReply or BulkReply            // There are two subsequent lines of MulitBulkReply, BulkHeader or BulkString            if isBulkHeader(line) {
                bulkLen = parseBulkHeader()
            } else {
                // We are reading a BulkString, which may be MulitBulkReply or BulkReply                args = append(args, line)
            }
            if len(args) == expectedArgsCount { // We have read all subsequent lines                // Return the result via ch                emitReply(ch)
                // Reset the status, prepare to parse the next Reply                readingMultiLine = false
                expectedArgsCount = 0
                args = nil
                bulkLen = 0
            }
        }
    }
}

func readLine(bufReader *, state *readState) ([]byte, bool, error) {
	var msg []byte
	var err error
	if  == 0 { // read simple line
		msg, err = ('\n')
		if err != nil {
			return nil, true, err
		}
		if len(msg) == 0 || msg[len(msg)-2] != '\r' {
			return nil, false, ("protocol error: " + string(msg))
		}
	} else { // read bulk line (binary safe)
		msg = make([]byte, +2)
		_, err = (bufReader, msg)
		if err != nil {
			return nil, true, err
		}
		if len(msg) == 0 ||
			msg[len(msg)-2] != '\r' ||
			msg[len(msg)-1] != '\n' {
			return nil, false, ("protocol error: " + string(msg))
		}
		 = 0
	}
	return msg, false, nil
}

func parseMultiBulkHeader(msg []byte, state *readState) error {
	var err error
	var expectedLine uint64
	expectedLine, err = (string(msg[1:len(msg)-2]), 10, 32)
	if err != nil {
		return ("protocol error: " + string(msg))
	}
	if expectedLine == 0 {
		 = 0
		return nil
	} else if expectedLine > 0 {
		// first line of multi bulk reply
		 = msg[0]
		 = true
		 = int(expectedLine)
		 = make([][]byte, 0, expectedLine)
		return nil
	} else {
		return ("protocol error: " + string(msg))
	}
}

func parseBulkHeader(msg []byte, state *readState) error {
	var err error
	, err = (string(msg[1:len(msg)-2]), 10, 64)
	if err != nil {
		return ("protocol error: " + string(msg))
	}
	if  == -1 { // null bulk
		return nil
	} else if  > 0 {
		 = msg[0]
		 = true
		 = 1
		 = make([][]byte, 0, 1)
		return nil
	} else {
		return ("protocol error: " + string(msg))
	}
}

func parseSingleLineReply(msg []byte) (, error) {
	str := (string(msg), "\n")
	str = (str, "\r")
	var result 
	switch msg[0] {
	case '+': // status reply
		result = (str[1:])
	case '-': // err reply
		result = (str[1:])
	case ':': // int reply
		val, err := (str[1:], 10, 64)
		if err != nil {
			return nil, ("protocol error: " + string(msg))
		}
		result = (val)
	default:
		// parse as text protocol
		strs := (str, " ")
		args := make([][]byte, len(strs))
		for i, s := range strs {
			args[i] = []byte(s)
		}
		result = (args)
	}
	return result, nil
}