// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package simplifiedchinese

import (
	

	
	
	
	
)

// HZGB2312 is the HZ-GB2312 encoding.
var HZGB2312 encoding.Encoding = &hzGB2312

var hzGB2312 = internal.Encoding{
	internal.FuncEncoding{hzGB2312NewDecoder, hzGB2312NewEncoder},
	"HZ-GB2312",
	identifier.HZGB2312,
}

func hzGB2312NewDecoder() transform.Transformer {
	return new(hzGB2312Decoder)
}

func hzGB2312NewEncoder() transform.Transformer {
	return new(hzGB2312Encoder)
}

const (
	asciiState = iota
	gbState
)

type hzGB2312Decoder int

func ( *hzGB2312Decoder) () {
	* = asciiState
}

func ( *hzGB2312Decoder) (,  []byte,  bool) (,  int,  error) {
	,  := rune(0), 0
:
	for ;  < len();  +=  {
		 := []
		if  >= utf8.RuneSelf {
			,  = utf8.RuneError, 1
			goto 
		}

		if  == '~' {
			if +1 >= len() {
				if ! {
					 = transform.ErrShortSrc
					break 
				}
				,  = utf8.RuneError, 1
				goto 
			}
			 = 2
			switch [+1] {
			case '{':
				* = gbState
				continue
			case '}':
				* = asciiState
				continue
			case '~':
				if  >= len() {
					 = transform.ErrShortDst
					break 
				}
				[] = '~'
				++
				continue
			case '\n':
				continue
			default:
				 = utf8.RuneError
				goto 
			}
		}

		if * == asciiState {
			,  = rune(), 1
		} else {
			if +1 >= len() {
				if ! {
					 = transform.ErrShortSrc
					break 
				}
				,  = utf8.RuneError, 1
				goto 
			}
			 = 2
			 := [+1]
			if  < 0x21 || 0x7e <=  ||  < 0x21 || 0x7f <=  {
				// error
			} else if  := int(-0x01)*190 + int(+0x3f);  < len(decode) {
				 = rune(decode[])
				if  != 0 {
					goto 
				}
			}
			if  > utf8.RuneSelf {
				// Be consistent and always treat non-ASCII as a single error.
				 = 1
			}
			 = utf8.RuneError
		}

	:
		if +utf8.RuneLen() > len() {
			 = transform.ErrShortDst
			break 
		}
		 += utf8.EncodeRune([:], )
	}
	return , , 
}

type hzGB2312Encoder int

func ( *hzGB2312Encoder) () {
	* = asciiState
}

func ( *hzGB2312Encoder) (,  []byte,  bool) (,  int,  error) {
	,  := rune(0), 0
	for ;  < len();  +=  {
		 = rune([])

		// Decode a 1-byte rune.
		if  < utf8.RuneSelf {
			 = 1
			if  == '~' {
				if +2 > len() {
					 = transform.ErrShortDst
					break
				}
				[+0] = '~'
				[+1] = '~'
				 += 2
				continue
			} else if * != asciiState {
				if +3 > len() {
					 = transform.ErrShortDst
					break
				}
				* = asciiState
				[+0] = '~'
				[+1] = '}'
				 += 2
			} else if  >= len() {
				 = transform.ErrShortDst
				break
			}
			[] = uint8()
			 += 1
			continue

		}

		// Decode a multi-byte rune.
		,  = utf8.DecodeRune([:])
		if  == 1 {
			// All valid runes of size 1 (those below utf8.RuneSelf) were
			// handled above. We have invalid UTF-8 or we haven't seen the
			// full character yet.
			if ! && !utf8.FullRune([:]) {
				 = transform.ErrShortSrc
				break
			}
		}

		// func init checks that the switch covers all tables.
		switch {
		case encode0Low <=  &&  < encode0High:
			if  = rune(encode0[-encode0Low]);  != 0 {
				goto 
			}
		case encode1Low <=  &&  < encode1High:
			if  = rune(encode1[-encode1Low]);  != 0 {
				goto 
			}
		case encode2Low <=  &&  < encode2High:
			if  = rune(encode2[-encode2Low]);  != 0 {
				goto 
			}
		case encode3Low <=  &&  < encode3High:
			if  = rune(encode3[-encode3Low]);  != 0 {
				goto 
			}
		case encode4Low <=  &&  < encode4High:
			if  = rune(encode4[-encode4Low]);  != 0 {
				goto 
			}
		}

	:
		// Switch back to ASCII state in case of error so that an ASCII
		// replacement character can be written in the correct state.
		if * != asciiState {
			if +2 > len() {
				 = transform.ErrShortDst
				break
			}
			[+0] = '~'
			[+1] = '}'
			 += 2
		}
		 = internal.ErrASCIIReplacement
		break

	:
		 := uint8(>>8) - 0x80
		 := uint8() - 0x80
		if  < 0x21 || 0x7e <=  ||  < 0x21 || 0x7f <=  {
			goto 
		}
		if * == asciiState {
			if +4 > len() {
				 = transform.ErrShortDst
				break
			}
			* = gbState
			[+0] = '~'
			[+1] = '{'
			 += 2
		} else if +2 > len() {
			 = transform.ErrShortDst
			break
		}
		[+0] = 
		[+1] = 
		 += 2
		continue
	}
	// TODO: should one always terminate in ASCII state to make it safe to
	// concatenate two HZ-GB2312-encoded strings?
	return , , 
}