diff --git a/constants.go b/constants.go index ebfce8a..96504a3 100644 --- a/constants.go +++ b/constants.go @@ -124,32 +124,32 @@ func getByteRange(start byte, end byte) []byte { return bytes } -var ToGroundBytes = getToGroundBytes() -var Executors = getExecuteBytes() +var toGroundBytes = getToGroundBytes() +var executors = getExecuteBytes() // SPACE 20+A0 hex Always and everywhere a blank space // Intermediate 20-2F hex !"#$%&'()*+,-./ -var Intermeds = getByteRange(0x20, 0x2F) +var intermeds = getByteRange(0x20, 0x2F) // Parameters 30-3F hex 0123456789:;<=>? // CSI Parameters 30-39, 3B hex 0123456789; -var CsiParams = getByteRange(0x30, 0x3F) +var csiParams = getByteRange(0x30, 0x3F) -var CsiCollectables = append(getByteRange(0x30, 0x39), getByteRange(0x3B, 0x3F)...) +var csiCollectables = append(getByteRange(0x30, 0x39), getByteRange(0x3B, 0x3F)...) // Uppercase 40-5F hex @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ -var UpperCase = getByteRange(0x40, 0x5F) +var upperCase = getByteRange(0x40, 0x5F) // Lowercase 60-7E hex `abcdefghijlkmnopqrstuvwxyz{|}~ -var LowerCase = getByteRange(0x60, 0x7E) +var lowerCase = getByteRange(0x60, 0x7E) // Alphabetics 40-7E hex (all of upper and lower case) -var Alphabetics = append(UpperCase, LowerCase...) +var alphabetics = append(upperCase, lowerCase...) -var Printables = getByteRange(0x20, 0x7F) +var printables = getByteRange(0x20, 0x7F) -var EscapeIntermediateToGroundBytes = getByteRange(0x30, 0x7E) -var EscapeToGroundBytes = getEscapeToGroundBytes() +var escapeIntermediateToGroundBytes = getByteRange(0x30, 0x7E) +var escapeToGroundBytes = getEscapeToGroundBytes() // See http://www.vt100.net/emu/vt500_parser.png for description of the complex // byte ranges below diff --git a/context.go b/context.go index d55cc2a..8d66e77 100644 --- a/context.go +++ b/context.go @@ -1,6 +1,6 @@ package ansiterm -type AnsiContext struct { +type ansiContext struct { currentChar byte paramBuffer []byte interBuffer []byte diff --git a/csi_entry_state.go b/csi_entry_state.go index 9fd4bd2..1bd6057 100644 --- a/csi_entry_state.go +++ b/csi_entry_state.go @@ -1,41 +1,41 @@ package ansiterm -type CsiEntryState struct { - BaseState +type csiEntryState struct { + baseState } -func (csiState CsiEntryState) Handle(b byte) (s State, e error) { +func (csiState csiEntryState) Handle(b byte) (s state, e error) { logger.Infof("CsiEntry::Handle %#x", b) - nextState, err := csiState.BaseState.Handle(b) + nextState, err := csiState.baseState.Handle(b) if nextState != nil || err != nil { return nextState, err } switch { - case sliceContains(Alphabetics, b): - return csiState.parser.Ground, nil - case sliceContains(CsiCollectables, b): - return csiState.parser.CsiParam, nil - case sliceContains(Executors, b): + case sliceContains(alphabetics, b): + return csiState.parser.ground, nil + case sliceContains(csiCollectables, b): + return csiState.parser.csiParam, nil + case sliceContains(executors, b): return csiState, csiState.parser.execute() } return csiState, nil } -func (csiState CsiEntryState) Transition(s State) error { +func (csiState csiEntryState) Transition(s state) error { logger.Infof("CsiEntry::Transition %s --> %s", csiState.Name(), s.Name()) - csiState.BaseState.Transition(s) + csiState.baseState.Transition(s) switch s { - case csiState.parser.Ground: + case csiState.parser.ground: return csiState.parser.csiDispatch() - case csiState.parser.CsiParam: + case csiState.parser.csiParam: switch { - case sliceContains(CsiParams, csiState.parser.context.currentChar): + case sliceContains(csiParams, csiState.parser.context.currentChar): csiState.parser.collectParam() - case sliceContains(Intermeds, csiState.parser.context.currentChar): + case sliceContains(intermeds, csiState.parser.context.currentChar): csiState.parser.collectInter() } } @@ -43,7 +43,7 @@ func (csiState CsiEntryState) Transition(s State) error { return nil } -func (csiState CsiEntryState) Enter() error { +func (csiState csiEntryState) Enter() error { csiState.parser.clear() return nil } diff --git a/csi_param_state.go b/csi_param_state.go index 27807dd..4be35c5 100644 --- a/csi_param_state.go +++ b/csi_param_state.go @@ -1,36 +1,36 @@ package ansiterm -type CsiParamState struct { - BaseState +type csiParamState struct { + baseState } -func (csiState CsiParamState) Handle(b byte) (s State, e error) { +func (csiState csiParamState) Handle(b byte) (s state, e error) { logger.Infof("CsiParam::Handle %#x", b) - nextState, err := csiState.BaseState.Handle(b) + nextState, err := csiState.baseState.Handle(b) if nextState != nil || err != nil { return nextState, err } switch { - case sliceContains(Alphabetics, b): - return csiState.parser.Ground, nil - case sliceContains(CsiCollectables, b): + case sliceContains(alphabetics, b): + return csiState.parser.ground, nil + case sliceContains(csiCollectables, b): csiState.parser.collectParam() return csiState, nil - case sliceContains(Executors, b): + case sliceContains(executors, b): return csiState, csiState.parser.execute() } return csiState, nil } -func (csiState CsiParamState) Transition(s State) error { +func (csiState csiParamState) Transition(s state) error { logger.Infof("CsiParam::Transition %s --> %s", csiState.Name(), s.Name()) - csiState.BaseState.Transition(s) + csiState.baseState.Transition(s) switch s { - case csiState.parser.Ground: + case csiState.parser.ground: return csiState.parser.csiDispatch() } diff --git a/escape_intermediate_state.go b/escape_intermediate_state.go index b14e0ce..2189eb6 100644 --- a/escape_intermediate_state.go +++ b/escape_intermediate_state.go @@ -1,34 +1,34 @@ package ansiterm -type EscapeIntermediateState struct { - BaseState +type escapeIntermediateState struct { + baseState } -func (escState EscapeIntermediateState) Handle(b byte) (s State, e error) { - logger.Infof("EscapeIntermediateState::Handle %#x", b) - nextState, err := escState.BaseState.Handle(b) +func (escState escapeIntermediateState) Handle(b byte) (s state, e error) { + logger.Infof("escapeIntermediateState::Handle %#x", b) + nextState, err := escState.baseState.Handle(b) if nextState != nil || err != nil { return nextState, err } switch { - case sliceContains(Intermeds, b): + case sliceContains(intermeds, b): return escState, escState.parser.collectInter() - case sliceContains(Executors, b): + case sliceContains(executors, b): return escState, escState.parser.execute() - case sliceContains(EscapeIntermediateToGroundBytes, b): - return escState.parser.Ground, nil + case sliceContains(escapeIntermediateToGroundBytes, b): + return escState.parser.ground, nil } return escState, nil } -func (escState EscapeIntermediateState) Transition(s State) error { - logger.Infof("EscapeIntermediateState::Transition %s --> %s", escState.Name(), s.Name()) - escState.BaseState.Transition(s) +func (escState escapeIntermediateState) Transition(s state) error { + logger.Infof("escapeIntermediateState::Transition %s --> %s", escState.Name(), s.Name()) + escState.baseState.Transition(s) switch s { - case escState.parser.Ground: + case escState.parser.ground: return escState.parser.escDispatch() } diff --git a/escape_state.go b/escape_state.go index 232dd8e..7b1b9ad 100644 --- a/escape_state.go +++ b/escape_state.go @@ -1,47 +1,47 @@ package ansiterm -type EscapeState struct { - BaseState +type escapeState struct { + baseState } -func (escState EscapeState) Handle(b byte) (s State, e error) { - logger.Infof("EscapeState::Handle %#x", b) - nextState, err := escState.BaseState.Handle(b) +func (escState escapeState) Handle(b byte) (s state, e error) { + logger.Infof("escapeState::Handle %#x", b) + nextState, err := escState.baseState.Handle(b) if nextState != nil || err != nil { return nextState, err } switch { case b == ANSI_ESCAPE_SECONDARY: - return escState.parser.CsiEntry, nil + return escState.parser.csiEntry, nil case b == ANSI_OSC_STRING_ENTRY: - return escState.parser.OscString, nil - case sliceContains(Executors, b): + return escState.parser.oscString, nil + case sliceContains(executors, b): return escState, escState.parser.execute() - case sliceContains(EscapeToGroundBytes, b): - return escState.parser.Ground, nil - case sliceContains(Intermeds, b): - return escState.parser.EscapeIntermediate, nil + case sliceContains(escapeToGroundBytes, b): + return escState.parser.ground, nil + case sliceContains(intermeds, b): + return escState.parser.escapeIntermediate, nil } return escState, nil } -func (escState EscapeState) Transition(s State) error { +func (escState escapeState) Transition(s state) error { logger.Infof("Escape::Transition %s --> %s", escState.Name(), s.Name()) - escState.BaseState.Transition(s) + escState.baseState.Transition(s) switch s { - case escState.parser.Ground: + case escState.parser.ground: return escState.parser.escDispatch() - case escState.parser.EscapeIntermediate: + case escState.parser.escapeIntermediate: return escState.parser.collectInter() } return nil } -func (escState EscapeState) Enter() error { +func (escState escapeState) Enter() error { escState.parser.clear() return nil } diff --git a/ground_state.go b/ground_state.go index d600e3e..52451e9 100644 --- a/ground_state.go +++ b/ground_state.go @@ -1,22 +1,22 @@ package ansiterm -type GroundState struct { - BaseState +type groundState struct { + baseState } -func (gs GroundState) Handle(b byte) (s State, e error) { +func (gs groundState) Handle(b byte) (s state, e error) { gs.parser.context.currentChar = b - nextState, err := gs.BaseState.Handle(b) + nextState, err := gs.baseState.Handle(b) if nextState != nil || err != nil { return nextState, err } switch { - case sliceContains(Printables, b): + case sliceContains(printables, b): return gs, gs.parser.print() - case sliceContains(Executors, b): + case sliceContains(executors, b): return gs, gs.parser.execute() } diff --git a/osc_string_state.go b/osc_string_state.go index 4490e3c..24062d4 100644 --- a/osc_string_state.go +++ b/osc_string_state.go @@ -1,19 +1,19 @@ package ansiterm -type OscStringState struct { - BaseState +type oscStringState struct { + baseState } -func (oscState OscStringState) Handle(b byte) (s State, e error) { +func (oscState oscStringState) Handle(b byte) (s state, e error) { logger.Infof("OscString::Handle %#x", b) - nextState, err := oscState.BaseState.Handle(b) + nextState, err := oscState.baseState.Handle(b) if nextState != nil || err != nil { return nextState, err } switch { case isOscStringTerminator(b): - return oscState.parser.Ground, nil + return oscState.parser.ground, nil } return oscState, nil diff --git a/parser.go b/parser.go index ef5e0ad..169f68d 100644 --- a/parser.go +++ b/parser.go @@ -2,7 +2,6 @@ package ansiterm import ( "errors" - "fmt" "io/ioutil" "os" @@ -12,18 +11,18 @@ import ( var logger *logrus.Logger type AnsiParser struct { - currState State + currState state eventHandler AnsiEventHandler - context *AnsiContext - CsiEntry State - CsiParam State - DcsEntry State - Escape State - EscapeIntermediate State - Error State - Ground State - OscString State - stateMap []State + context *ansiContext + csiEntry state + csiParam state + dcsEntry state + escape state + escapeIntermediate state + error state + ground state + oscString state + stateMap []state } func CreateParser(initialState string, evtHandler AnsiEventHandler) *AnsiParser { @@ -41,27 +40,27 @@ func CreateParser(initialState string, evtHandler AnsiEventHandler) *AnsiParser parser := &AnsiParser{ eventHandler: evtHandler, - context: &AnsiContext{}, + context: &ansiContext{}, } - parser.CsiEntry = CsiEntryState{BaseState{name: "CsiEntry", parser: parser}} - parser.CsiParam = CsiParamState{BaseState{name: "CsiParam", parser: parser}} - parser.DcsEntry = DcsEntryState{BaseState{name: "DcsEntry", parser: parser}} - parser.Escape = EscapeState{BaseState{name: "Escape", parser: parser}} - parser.EscapeIntermediate = EscapeIntermediateState{BaseState{name: "EscapeIntermediate", parser: parser}} - parser.Error = ErrorState{BaseState{name: "Error", parser: parser}} - parser.Ground = GroundState{BaseState{name: "Ground", parser: parser}} - parser.OscString = OscStringState{BaseState{name: "OscString", parser: parser}} - - parser.stateMap = []State{ - parser.CsiEntry, - parser.CsiParam, - parser.DcsEntry, - parser.Escape, - parser.EscapeIntermediate, - parser.Error, - parser.Ground, - parser.OscString, + parser.csiEntry = csiEntryState{baseState{name: "CsiEntry", parser: parser}} + parser.csiParam = csiParamState{baseState{name: "CsiParam", parser: parser}} + parser.dcsEntry = dcsEntryState{baseState{name: "DcsEntry", parser: parser}} + parser.escape = escapeState{baseState{name: "Escape", parser: parser}} + parser.escapeIntermediate = escapeIntermediateState{baseState{name: "EscapeIntermediate", parser: parser}} + parser.error = errorState{baseState{name: "Error", parser: parser}} + parser.ground = groundState{baseState{name: "Ground", parser: parser}} + parser.oscString = oscStringState{baseState{name: "OscString", parser: parser}} + + parser.stateMap = []state{ + parser.csiEntry, + parser.csiParam, + parser.dcsEntry, + parser.escape, + parser.escapeIntermediate, + parser.error, + parser.ground, + parser.oscString, } parser.currState = getState(initialState, parser.stateMap) @@ -70,7 +69,7 @@ func CreateParser(initialState string, evtHandler AnsiEventHandler) *AnsiParser return parser } -func getState(name string, states []State) State { +func getState(name string, states []state) state { for _, el := range states { if el.Name() == name { return el @@ -99,7 +98,7 @@ func (ap *AnsiParser) handle(b byte) error { if newState == nil { logger.Warning("newState is nil") - return errors.New(fmt.Sprintf("New state of 'nil' is invalid.")) + return errors.New("New state of 'nil' is invalid.") } if newState != ap.currState { @@ -111,7 +110,7 @@ func (ap *AnsiParser) handle(b byte) error { return nil } -func (ap *AnsiParser) changeState(newState State) error { +func (ap *AnsiParser) changeState(newState state) error { logger.Infof("ChangeState %s --> %s", ap.currState.Name(), newState.Name()) // Exit old state diff --git a/parser_action_helpers.go b/parser_action_helpers.go index 4388020..8b69a67 100644 --- a/parser_action_helpers.go +++ b/parser_action_helpers.go @@ -31,7 +31,7 @@ func parseParams(bytes []byte) ([]string, error) { return params, nil } -func parseCmd(context AnsiContext) (string, error) { +func parseCmd(context ansiContext) (string, error) { return string(context.currentChar), nil } diff --git a/parser_actions.go b/parser_actions.go index 260e6aa..58750a2 100644 --- a/parser_actions.go +++ b/parser_actions.go @@ -113,7 +113,7 @@ func (ap *AnsiParser) print() error { } func (ap *AnsiParser) clear() error { - ap.context = &AnsiContext{} + ap.context = &ansiContext{} return nil } diff --git a/parser_test.go b/parser_test.go index 6e6deb9..cd4888f 100644 --- a/parser_test.go +++ b/parser_test.go @@ -6,18 +6,18 @@ import ( ) func TestStateTransitions(t *testing.T) { - stateTransitionHelper(t, "CsiEntry", "Ground", Alphabetics) - stateTransitionHelper(t, "CsiEntry", "CsiParam", CsiCollectables) + stateTransitionHelper(t, "CsiEntry", "Ground", alphabetics) + stateTransitionHelper(t, "CsiEntry", "CsiParam", csiCollectables) stateTransitionHelper(t, "Escape", "CsiEntry", []byte{ANSI_ESCAPE_SECONDARY}) stateTransitionHelper(t, "Escape", "OscString", []byte{0x5D}) - stateTransitionHelper(t, "Escape", "Ground", EscapeToGroundBytes) - stateTransitionHelper(t, "Escape", "EscapeIntermediate", Intermeds) - stateTransitionHelper(t, "EscapeIntermediate", "EscapeIntermediate", Intermeds) - stateTransitionHelper(t, "EscapeIntermediate", "EscapeIntermediate", Executors) - stateTransitionHelper(t, "EscapeIntermediate", "Ground", EscapeIntermediateToGroundBytes) + stateTransitionHelper(t, "Escape", "Ground", escapeToGroundBytes) + stateTransitionHelper(t, "Escape", "EscapeIntermediate", intermeds) + stateTransitionHelper(t, "EscapeIntermediate", "EscapeIntermediate", intermeds) + stateTransitionHelper(t, "EscapeIntermediate", "EscapeIntermediate", executors) + stateTransitionHelper(t, "EscapeIntermediate", "Ground", escapeIntermediateToGroundBytes) stateTransitionHelper(t, "OscString", "Ground", []byte{ANSI_BEL}) stateTransitionHelper(t, "OscString", "Ground", []byte{0x5C}) - stateTransitionHelper(t, "Ground", "Ground", Executors) + stateTransitionHelper(t, "Ground", "Ground", executors) } func TestAnyToX(t *testing.T) { @@ -25,27 +25,27 @@ func TestAnyToX(t *testing.T) { anyToXHelper(t, []byte{DCS_ENTRY}, "DcsEntry") anyToXHelper(t, []byte{OSC_STRING}, "OscString") anyToXHelper(t, []byte{CSI_ENTRY}, "CsiEntry") - anyToXHelper(t, ToGroundBytes, "Ground") + anyToXHelper(t, toGroundBytes, "Ground") } func TestCollectCsiParams(t *testing.T) { parser, _ := createTestParser("CsiEntry") - parser.Parse(CsiCollectables) + parser.Parse(csiCollectables) buffer := parser.context.paramBuffer bufferCount := len(buffer) - if bufferCount != len(CsiCollectables) { + if bufferCount != len(csiCollectables) { t.Errorf("Buffer: %v", buffer) - t.Errorf("CsiParams: %v", CsiCollectables) - t.Errorf("Buffer count failure: %d != %d", bufferCount, len(CsiParams)) + t.Errorf("CsiParams: %v", csiCollectables) + t.Errorf("Buffer count failure: %d != %d", bufferCount, len(csiParams)) return } - for i, v := range CsiCollectables { + for i, v := range csiCollectables { if v != buffer[i] { t.Errorf("Buffer: %v", buffer) - t.Errorf("CsiParams: %v", CsiParams) + t.Errorf("CsiParams: %v", csiParams) t.Errorf("Mismatch at buffer[%d] = %d", i, buffer[i]) } } @@ -105,10 +105,10 @@ func TestScroll(t *testing.T) { func TestPrint(t *testing.T) { parser, evtHandler := createTestParser("Ground") - parser.Parse(Printables) + parser.Parse(printables) validateState(t, parser.currState, "Ground") - for i, v := range Printables { + for i, v := range printables { expectedCall := fmt.Sprintf("Print([%s])", string(v)) actualCall := evtHandler.FunctionCalls[i] if actualCall != expectedCall { diff --git a/parser_test_helpers.go b/parser_test_helpers_test.go similarity index 100% rename from parser_test_helpers.go rename to parser_test_helpers_test.go diff --git a/parser_test_utilities.go b/parser_test_utilities_test.go similarity index 86% rename from parser_test_utilities.go rename to parser_test_utilities_test.go index 51d1d49..78b885c 100644 --- a/parser_test_utilities.go +++ b/parser_test_utilities_test.go @@ -11,7 +11,7 @@ func createTestParser(s string) (*AnsiParser, *TestAnsiEventHandler) { return parser, evtHandler } -func validateState(t *testing.T, actualState State, expectedStateName string) { +func validateState(t *testing.T, actualState state, expectedStateName string) { actualName := "Nil" if actualState != nil { @@ -19,7 +19,7 @@ func validateState(t *testing.T, actualState State, expectedStateName string) { } if actualName != expectedStateName { - t.Errorf("Invalid State: '%s' != '%s'", actualName, expectedStateName) + t.Errorf("Invalid state: '%s' != '%s'", actualName, expectedStateName) } } @@ -43,13 +43,13 @@ func validateFuncCalls(t *testing.T, actualCalls []string, expectedCalls []strin } } -func fillContext(context *AnsiContext) { +func fillContext(context *ansiContext) { context.currentChar = 'A' context.paramBuffer = []byte{'C', 'D', 'E'} context.interBuffer = []byte{'F', 'G', 'H'} } -func validateEmptyContext(t *testing.T, context *AnsiContext) { +func validateEmptyContext(t *testing.T, context *ansiContext) { var expectedCurrChar byte = 0x0 if context.currentChar != expectedCurrChar { t.Errorf("Currentchar mismatch '%#x' != '%#x'", context.currentChar, expectedCurrChar) diff --git a/states.go b/states.go index 0cbdcb3..f2ea1fc 100644 --- a/states.go +++ b/states.go @@ -1,52 +1,52 @@ package ansiterm -type StateId int +type stateID int -type State interface { +type state interface { Enter() error Exit() error - Handle(byte) (State, error) + Handle(byte) (state, error) Name() string - Transition(State) error + Transition(state) error } -type BaseState struct { +type baseState struct { name string parser *AnsiParser } -func (base BaseState) Enter() error { +func (base baseState) Enter() error { return nil } -func (base BaseState) Exit() error { +func (base baseState) Exit() error { return nil } -func (base BaseState) Handle(b byte) (s State, e error) { +func (base baseState) Handle(b byte) (s state, e error) { switch { case b == CSI_ENTRY: - return base.parser.CsiEntry, nil + return base.parser.csiEntry, nil case b == DCS_ENTRY: - return base.parser.DcsEntry, nil + return base.parser.dcsEntry, nil case b == ANSI_ESCAPE_PRIMARY: - return base.parser.Escape, nil + return base.parser.escape, nil case b == OSC_STRING: - return base.parser.OscString, nil - case sliceContains(ToGroundBytes, b): - return base.parser.Ground, nil + return base.parser.oscString, nil + case sliceContains(toGroundBytes, b): + return base.parser.ground, nil } return nil, nil } -func (base BaseState) Name() string { +func (base baseState) Name() string { return base.name } -func (base BaseState) Transition(s State) error { - if s == base.parser.Ground { +func (base baseState) Transition(s state) error { + if s == base.parser.ground { execBytes := []byte{0x18} execBytes = append(execBytes, 0x1A) execBytes = append(execBytes, getByteRange(0x80, 0x8F)...) @@ -62,10 +62,10 @@ func (base BaseState) Transition(s State) error { return nil } -type DcsEntryState struct { - BaseState +type dcsEntryState struct { + baseState } -type ErrorState struct { - BaseState +type errorState struct { + baseState } diff --git a/test_event_handler.go b/test_event_handler_test.go similarity index 100% rename from test_event_handler.go rename to test_event_handler_test.go diff --git a/winterm/ansi.go b/winterm/ansi.go index 78fe92f..daf2f06 100644 --- a/winterm/ansi.go +++ b/winterm/ansi.go @@ -9,7 +9,7 @@ import ( "strings" "syscall" - . "github.com/Azure/go-ansiterm" + "github.com/Azure/go-ansiterm" ) // Windows keyboard constants @@ -85,17 +85,17 @@ func newAnsiCommand(command []byte) *ansiCommand { if lastCharIndex != 0 { start := 1 // skip if double char escape sequence - if command[0] == ANSI_ESCAPE_PRIMARY && command[1] == ANSI_ESCAPE_SECONDARY { + if command[0] == ansiterm.ANSI_ESCAPE_PRIMARY && command[1] == ansiterm.ANSI_ESCAPE_SECONDARY { start++ } // convert this to GetNextParam method - ac.Parameters = strings.Split(string(command[start:lastCharIndex]), ANSI_PARAMETER_SEP) + ac.Parameters = strings.Split(string(command[start:lastCharIndex]), ansiterm.ANSI_PARAMETER_SEP) } return ac } -func (ac *ansiCommand) paramAsSHORT(index int, defaultValue SHORT) SHORT { +func (ac *ansiCommand) paramAsSHORT(index int, defaultValue int16) int16 { if index < 0 || index >= len(ac.Parameters) { return defaultValue } @@ -105,7 +105,7 @@ func (ac *ansiCommand) paramAsSHORT(index int, defaultValue SHORT) SHORT { return defaultValue } - return SHORT(param) + return int16(param) } func (ac *ansiCommand) String() string { @@ -119,12 +119,12 @@ func (ac *ansiCommand) String() string { // See http://manpages.ubuntu.com/manpages/intrepid/man4/console_codes.4.html. func isAnsiCommandChar(b byte) bool { switch { - case ANSI_COMMAND_FIRST <= b && b <= ANSI_COMMAND_LAST && b != ANSI_ESCAPE_SECONDARY: + case ansiterm.ANSI_COMMAND_FIRST <= b && b <= ansiterm.ANSI_COMMAND_LAST && b != ansiterm.ANSI_ESCAPE_SECONDARY: return true - case b == ANSI_CMD_G1 || b == ANSI_CMD_OSC || b == ANSI_CMD_DECPAM || b == ANSI_CMD_DECPNM: + case b == ansiterm.ANSI_CMD_G1 || b == ansiterm.ANSI_CMD_OSC || b == ansiterm.ANSI_CMD_DECPAM || b == ansiterm.ANSI_CMD_DECPNM: // non-CSI escape sequence terminator return true - case b == ANSI_CMD_STR_TERM || b == ANSI_BEL: + case b == ansiterm.ANSI_CMD_STR_TERM || b == ansiterm.ANSI_BEL: // String escape sequence terminator return true } @@ -132,11 +132,11 @@ func isAnsiCommandChar(b byte) bool { } func isXtermOscSequence(command []byte, current byte) bool { - return (len(command) >= 2 && command[0] == ANSI_ESCAPE_PRIMARY && command[1] == ANSI_CMD_OSC && current != ANSI_BEL) + return (len(command) >= 2 && command[0] == ansiterm.ANSI_ESCAPE_PRIMARY && command[1] == ansiterm.ANSI_CMD_OSC && current != ansiterm.ANSI_BEL) } func isCharacterSelectionCmdChar(b byte) bool { - return (b == ANSI_CMD_G0 || b == ANSI_CMD_G1 || b == ANSI_CMD_G2 || b == ANSI_CMD_G3) + return (b == ansiterm.ANSI_CMD_G0 || b == ansiterm.ANSI_CMD_G1 || b == ansiterm.ANSI_CMD_G2 || b == ansiterm.ANSI_CMD_G3) } // bytesToHex converts a slice of bytes to a human-readable string. @@ -150,7 +150,7 @@ func bytesToHex(b []byte) string { // ensureInRange adjusts the passed value, if necessary, to ensure it is within // the passed min / max range. -func ensureInRange(n SHORT, min SHORT, max SHORT) SHORT { +func ensureInRange(n int16, min int16, max int16) int16 { if n < min { return min } else if n > max { diff --git a/winterm/api.go b/winterm/api.go index 1f2f385..462d92f 100644 --- a/winterm/api.go +++ b/winterm/api.go @@ -66,21 +66,21 @@ const ( // -- The attributes are combined to produce various colors (e.g., Blue + Green will create Cyan). // Clearing all foreground or background colors results in black; setting all creates white. // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms682088(v=vs.85).aspx#_win32_character_attributes. - FOREGROUND_BLUE WORD = 0x0001 - FOREGROUND_GREEN WORD = 0x0002 - FOREGROUND_RED WORD = 0x0004 - FOREGROUND_INTENSITY WORD = 0x0008 - FOREGROUND_MASK WORD = 0x000F - - BACKGROUND_BLUE WORD = 0x0010 - BACKGROUND_GREEN WORD = 0x0020 - BACKGROUND_RED WORD = 0x0040 - BACKGROUND_INTENSITY WORD = 0x0080 - BACKGROUND_MASK WORD = 0x00F0 - - COMMON_LVB_MASK WORD = 0xFF00 - COMMON_LVB_REVERSE_VIDEO WORD = 0x4000 - COMMON_LVB_UNDERSCORE WORD = 0x8000 + FOREGROUND_BLUE uint16 = 0x0001 + FOREGROUND_GREEN uint16 = 0x0002 + FOREGROUND_RED uint16 = 0x0004 + FOREGROUND_INTENSITY uint16 = 0x0008 + FOREGROUND_MASK uint16 = 0x000F + + BACKGROUND_BLUE uint16 = 0x0010 + BACKGROUND_GREEN uint16 = 0x0020 + BACKGROUND_RED uint16 = 0x0040 + BACKGROUND_INTENSITY uint16 = 0x0080 + BACKGROUND_MASK uint16 = 0x00F0 + + COMMON_LVB_MASK uint16 = 0xFF00 + COMMON_LVB_REVERSE_VIDEO uint16 = 0x4000 + COMMON_LVB_UNDERSCORE uint16 = 0x8000 // Input event types // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683499(v=vs.85).aspx. @@ -104,60 +104,53 @@ const ( ) // Windows API Console types -// -- See https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx for core types (e.g., SHORT) // -- See https://msdn.microsoft.com/en-us/library/windows/desktop/ms682101(v=vs.85).aspx for Console specific types (e.g., COORD) // -- See https://msdn.microsoft.com/en-us/library/aa296569(v=vs.60).aspx for comments on alignment type ( - SHORT int16 - BOOL int32 - WORD uint16 - WCHAR uint16 - DWORD uint32 - CHAR_INFO struct { - UnicodeChar WCHAR - Attributes WORD + UnicodeChar uint16 + Attributes uint16 } CONSOLE_CURSOR_INFO struct { - Size DWORD - Visible BOOL + Size uint32 + Visible int32 } CONSOLE_SCREEN_BUFFER_INFO struct { Size COORD CursorPosition COORD - Attributes WORD + Attributes uint16 Window SMALL_RECT MaximumWindowSize COORD } COORD struct { - X SHORT - Y SHORT + X int16 + Y int16 } SMALL_RECT struct { - Left SHORT - Top SHORT - Right SHORT - Bottom SHORT + Left int16 + Top int16 + Right int16 + Bottom int16 } // INPUT_RECORD is a C/C++ union of which KEY_EVENT_RECORD is one case, it is also the largest // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683499(v=vs.85).aspx. INPUT_RECORD struct { - EventType WORD + EventType uint16 KeyEvent KEY_EVENT_RECORD } KEY_EVENT_RECORD struct { - KeyDown BOOL - RepeatCount WORD - VirtualKeyCode WORD - VirtualScanCode WORD - UnicodeChar WCHAR - ControlKeyState DWORD + KeyDown int32 + RepeatCount uint16 + VirtualKeyCode uint16 + VirtualScanCode uint16 + UnicodeChar uint16 + ControlKeyState uint32 } WINDOW_BUFFER_SIZE struct { @@ -165,12 +158,12 @@ type ( } ) -// boolToBOOL converts a Go bool into a Windows BOOL. -func boolToBOOL(f bool) BOOL { +// boolToBOOL converts a Go bool into a Windows int32. +func boolToBOOL(f bool) int32 { if f { - return BOOL(1) + return int32(1) } else { - return BOOL(0) + return int32(0) } } @@ -242,7 +235,7 @@ func SetConsoleScreenBufferSize(handle uintptr, coord COORD) error { // SetConsoleTextAttribute sets the attributes of characters written to the // console screen buffer by the WriteFile or WriteConsole function. // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms686047(v=vs.85).aspx. -func SetConsoleTextAttribute(handle uintptr, attribute WORD) error { +func SetConsoleTextAttribute(handle uintptr, attribute uint16) error { r1, r2, err := setConsoleTextAttributeProc.Call(handle, uintptr(attribute), 0) use(attribute) return checkError(r1, r2, err) @@ -280,7 +273,7 @@ func ReadConsoleInput(handle uintptr, buffer []INPUT_RECORD, count *uint32) erro // It returns true if the handle was signaled; false otherwise. // See https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx. func WaitForSingleObject(handle uintptr, msWait uint32) (bool, error) { - r1, _, err := waitForSingleObjectProc.Call(handle, uintptr(DWORD(msWait))) + r1, _, err := waitForSingleObjectProc.Call(handle, uintptr(uint32(msWait))) switch r1 { case WAIT_ABANDONED, WAIT_TIMEOUT: return false, nil @@ -320,8 +313,8 @@ func checkError(r1, r2 uintptr, err error) error { // coordToPointer converts a COORD into a uintptr (by fooling the type system). func coordToPointer(c COORD) uintptr { - // Note: This code assumes the two SHORTs are correctly laid out; the "cast" to DWORD is just to get a pointer to pass. - return uintptr(*((*DWORD)(unsafe.Pointer(&c)))) + // Note: This code assumes the two SHORTs are correctly laid out; the "cast" to uint32 is just to get a pointer to pass. + return uintptr(*((*uint32)(unsafe.Pointer(&c)))) } // use is a no-op, but the compiler cannot see that it is. diff --git a/winterm/attr_translation.go b/winterm/attr_translation.go index 94665db..cbec8f7 100644 --- a/winterm/attr_translation.go +++ b/winterm/attr_translation.go @@ -2,9 +2,7 @@ package winterm -import ( - . "github.com/Azure/go-ansiterm" -) +import "github.com/Azure/go-ansiterm" const ( FOREGROUND_COLOR_MASK = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE @@ -13,83 +11,83 @@ const ( // collectAnsiIntoWindowsAttributes modifies the passed Windows text mode flags to reflect the // request represented by the passed ANSI mode. -func collectAnsiIntoWindowsAttributes(windowsMode WORD, inverted bool, baseMode WORD, ansiMode SHORT) (WORD, bool) { +func collectAnsiIntoWindowsAttributes(windowsMode uint16, inverted bool, baseMode uint16, ansiMode int16) (uint16, bool) { switch ansiMode { // Mode styles - case ANSI_SGR_BOLD: + case ansiterm.ANSI_SGR_BOLD: windowsMode = windowsMode | FOREGROUND_INTENSITY - case ANSI_SGR_DIM, ANSI_SGR_BOLD_DIM_OFF: + case ansiterm.ANSI_SGR_DIM, ansiterm.ANSI_SGR_BOLD_DIM_OFF: windowsMode &^= FOREGROUND_INTENSITY - case ANSI_SGR_UNDERLINE: + case ansiterm.ANSI_SGR_UNDERLINE: windowsMode = windowsMode | COMMON_LVB_UNDERSCORE - case ANSI_SGR_REVERSE: + case ansiterm.ANSI_SGR_REVERSE: inverted = true - case ANSI_SGR_REVERSE_OFF: + case ansiterm.ANSI_SGR_REVERSE_OFF: inverted = false - case ANSI_SGR_UNDERLINE_OFF: + case ansiterm.ANSI_SGR_UNDERLINE_OFF: windowsMode &^= COMMON_LVB_UNDERSCORE // Foreground colors - case ANSI_SGR_FOREGROUND_DEFAULT: + case ansiterm.ANSI_SGR_FOREGROUND_DEFAULT: windowsMode = (windowsMode &^ FOREGROUND_MASK) | (baseMode & FOREGROUND_MASK) - case ANSI_SGR_FOREGROUND_BLACK: + case ansiterm.ANSI_SGR_FOREGROUND_BLACK: windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) - case ANSI_SGR_FOREGROUND_RED: + case ansiterm.ANSI_SGR_FOREGROUND_RED: windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED - case ANSI_SGR_FOREGROUND_GREEN: + case ansiterm.ANSI_SGR_FOREGROUND_GREEN: windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_GREEN - case ANSI_SGR_FOREGROUND_YELLOW: + case ansiterm.ANSI_SGR_FOREGROUND_YELLOW: windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_GREEN - case ANSI_SGR_FOREGROUND_BLUE: + case ansiterm.ANSI_SGR_FOREGROUND_BLUE: windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_BLUE - case ANSI_SGR_FOREGROUND_MAGENTA: + case ansiterm.ANSI_SGR_FOREGROUND_MAGENTA: windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_BLUE - case ANSI_SGR_FOREGROUND_CYAN: + case ansiterm.ANSI_SGR_FOREGROUND_CYAN: windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_GREEN | FOREGROUND_BLUE - case ANSI_SGR_FOREGROUND_WHITE: + case ansiterm.ANSI_SGR_FOREGROUND_WHITE: windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE // Background colors - case ANSI_SGR_BACKGROUND_DEFAULT: + case ansiterm.ANSI_SGR_BACKGROUND_DEFAULT: // Black with no intensity windowsMode = (windowsMode &^ BACKGROUND_MASK) | (baseMode & BACKGROUND_MASK) - case ANSI_SGR_BACKGROUND_BLACK: + case ansiterm.ANSI_SGR_BACKGROUND_BLACK: windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) - case ANSI_SGR_BACKGROUND_RED: + case ansiterm.ANSI_SGR_BACKGROUND_RED: windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED - case ANSI_SGR_BACKGROUND_GREEN: + case ansiterm.ANSI_SGR_BACKGROUND_GREEN: windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_GREEN - case ANSI_SGR_BACKGROUND_YELLOW: + case ansiterm.ANSI_SGR_BACKGROUND_YELLOW: windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_GREEN - case ANSI_SGR_BACKGROUND_BLUE: + case ansiterm.ANSI_SGR_BACKGROUND_BLUE: windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_BLUE - case ANSI_SGR_BACKGROUND_MAGENTA: + case ansiterm.ANSI_SGR_BACKGROUND_MAGENTA: windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_BLUE - case ANSI_SGR_BACKGROUND_CYAN: + case ansiterm.ANSI_SGR_BACKGROUND_CYAN: windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_GREEN | BACKGROUND_BLUE - case ANSI_SGR_BACKGROUND_WHITE: + case ansiterm.ANSI_SGR_BACKGROUND_WHITE: windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE } @@ -97,6 +95,6 @@ func collectAnsiIntoWindowsAttributes(windowsMode WORD, inverted bool, baseMode } // invertAttributes inverts the foreground and background colors of a Windows attributes value -func invertAttributes(windowsMode WORD) WORD { +func invertAttributes(windowsMode uint16) uint16 { return (COMMON_LVB_MASK & windowsMode) | ((FOREGROUND_MASK & windowsMode) << 4) | ((BACKGROUND_MASK & windowsMode) >> 4) } diff --git a/winterm/cursor_helpers.go b/winterm/cursor_helpers.go index e4b1c25..f015723 100644 --- a/winterm/cursor_helpers.go +++ b/winterm/cursor_helpers.go @@ -3,11 +3,11 @@ package winterm const ( - Horizontal = iota - Vertical + horizontal = iota + vertical ) -func (h *WindowsAnsiEventHandler) getCursorWindow(info *CONSOLE_SCREEN_BUFFER_INFO) SMALL_RECT { +func (h *windowsAnsiEventHandler) getCursorWindow(info *CONSOLE_SCREEN_BUFFER_INFO) SMALL_RECT { if h.originMode { sr := h.effectiveSr(info.Window) return SMALL_RECT{ @@ -27,7 +27,7 @@ func (h *WindowsAnsiEventHandler) getCursorWindow(info *CONSOLE_SCREEN_BUFFER_IN } // setCursorPosition sets the cursor to the specified position, bounded to the screen size -func (h *WindowsAnsiEventHandler) setCursorPosition(position COORD, window SMALL_RECT) error { +func (h *windowsAnsiEventHandler) setCursorPosition(position COORD, window SMALL_RECT) error { position.X = ensureInRange(position.X, window.Left, window.Right) position.Y = ensureInRange(position.Y, window.Top, window.Bottom) err := SetConsoleCursorPosition(h.fd, position) @@ -38,15 +38,15 @@ func (h *WindowsAnsiEventHandler) setCursorPosition(position COORD, window SMALL return err } -func (h *WindowsAnsiEventHandler) moveCursorVertical(param int) error { - return h.moveCursor(Vertical, param) +func (h *windowsAnsiEventHandler) moveCursorVertical(param int) error { + return h.moveCursor(vertical, param) } -func (h *WindowsAnsiEventHandler) moveCursorHorizontal(param int) error { - return h.moveCursor(Horizontal, param) +func (h *windowsAnsiEventHandler) moveCursorHorizontal(param int) error { + return h.moveCursor(horizontal, param) } -func (h *WindowsAnsiEventHandler) moveCursor(moveMode int, param int) error { +func (h *windowsAnsiEventHandler) moveCursor(moveMode int, param int) error { info, err := GetConsoleScreenBufferInfo(h.fd) if err != nil { return err @@ -54,10 +54,10 @@ func (h *WindowsAnsiEventHandler) moveCursor(moveMode int, param int) error { position := info.CursorPosition switch moveMode { - case Horizontal: - position.X += SHORT(param) - case Vertical: - position.Y += SHORT(param) + case horizontal: + position.X += int16(param) + case vertical: + position.Y += int16(param) } if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil { @@ -67,7 +67,7 @@ func (h *WindowsAnsiEventHandler) moveCursor(moveMode int, param int) error { return nil } -func (h *WindowsAnsiEventHandler) moveCursorLine(param int) error { +func (h *windowsAnsiEventHandler) moveCursorLine(param int) error { info, err := GetConsoleScreenBufferInfo(h.fd) if err != nil { return err @@ -75,7 +75,7 @@ func (h *WindowsAnsiEventHandler) moveCursorLine(param int) error { position := info.CursorPosition position.X = 0 - position.Y += SHORT(param) + position.Y += int16(param) if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil { return err @@ -84,14 +84,14 @@ func (h *WindowsAnsiEventHandler) moveCursorLine(param int) error { return nil } -func (h *WindowsAnsiEventHandler) moveCursorColumn(param int) error { +func (h *windowsAnsiEventHandler) moveCursorColumn(param int) error { info, err := GetConsoleScreenBufferInfo(h.fd) if err != nil { return err } position := info.CursorPosition - position.X = SHORT(param) - 1 + position.X = int16(param) - 1 if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil { return err diff --git a/winterm/erase_helpers.go b/winterm/erase_helpers.go index f02a5b2..244b5fa 100644 --- a/winterm/erase_helpers.go +++ b/winterm/erase_helpers.go @@ -2,11 +2,9 @@ package winterm -import ( - . "github.com/Azure/go-ansiterm" -) +import "github.com/Azure/go-ansiterm" -func (h *WindowsAnsiEventHandler) clearRange(attributes WORD, fromCoord COORD, toCoord COORD) error { +func (h *windowsAnsiEventHandler) clearRange(attributes uint16, fromCoord COORD, toCoord COORD) error { // Ignore an invalid (negative area) request if toCoord.Y < fromCoord.Y { return nil @@ -60,7 +58,7 @@ func (h *WindowsAnsiEventHandler) clearRange(attributes WORD, fromCoord COORD, t return nil } -func (h *WindowsAnsiEventHandler) clearRect(attributes WORD, fromCoord COORD, toCoord COORD) error { +func (h *windowsAnsiEventHandler) clearRect(attributes uint16, fromCoord COORD, toCoord COORD) error { region := SMALL_RECT{Top: fromCoord.Y, Left: fromCoord.X, Bottom: toCoord.Y, Right: toCoord.X} width := toCoord.X - fromCoord.X + 1 height := toCoord.Y - fromCoord.Y + 1 @@ -72,7 +70,7 @@ func (h *WindowsAnsiEventHandler) clearRect(attributes WORD, fromCoord COORD, to buffer := make([]CHAR_INFO, size) - char := CHAR_INFO{WCHAR(FILL_CHARACTER), attributes} + char := CHAR_INFO{ansiterm.FILL_CHARACTER, attributes} for i := 0; i < int(size); i++ { buffer[i] = char } diff --git a/winterm/scroll_helper.go b/winterm/scroll_helper.go index ed19982..706d270 100644 --- a/winterm/scroll_helper.go +++ b/winterm/scroll_helper.go @@ -3,9 +3,9 @@ package winterm // effectiveSr gets the current effective scroll region in buffer coordinates -func (h *WindowsAnsiEventHandler) effectiveSr(window SMALL_RECT) scrollRegion { - top := AddInRange(window.Top, h.sr.top, window.Top, window.Bottom) - bottom := AddInRange(window.Top, h.sr.bottom, window.Top, window.Bottom) +func (h *windowsAnsiEventHandler) effectiveSr(window SMALL_RECT) scrollRegion { + top := addInRange(window.Top, h.sr.top, window.Top, window.Bottom) + bottom := addInRange(window.Top, h.sr.bottom, window.Top, window.Bottom) if top >= bottom { top = window.Top bottom = window.Bottom @@ -13,7 +13,7 @@ func (h *WindowsAnsiEventHandler) effectiveSr(window SMALL_RECT) scrollRegion { return scrollRegion{top: top, bottom: bottom} } -func (h *WindowsAnsiEventHandler) scrollUp(param int) error { +func (h *windowsAnsiEventHandler) scrollUp(param int) error { info, err := GetConsoleScreenBufferInfo(h.fd) if err != nil { return err @@ -23,11 +23,11 @@ func (h *WindowsAnsiEventHandler) scrollUp(param int) error { return h.scroll(param, sr, info) } -func (h *WindowsAnsiEventHandler) scrollDown(param int) error { +func (h *windowsAnsiEventHandler) scrollDown(param int) error { return h.scrollUp(-param) } -func (h *WindowsAnsiEventHandler) deleteLines(param int) error { +func (h *windowsAnsiEventHandler) deleteLines(param int) error { info, err := GetConsoleScreenBufferInfo(h.fd) if err != nil { return err @@ -44,12 +44,12 @@ func (h *WindowsAnsiEventHandler) deleteLines(param int) error { } } -func (h *WindowsAnsiEventHandler) insertLines(param int) error { +func (h *windowsAnsiEventHandler) insertLines(param int) error { return h.deleteLines(-param) } // scroll scrolls the provided scroll region by param lines. The scroll region is in buffer coordinates. -func (h *WindowsAnsiEventHandler) scroll(param int, sr scrollRegion, info *CONSOLE_SCREEN_BUFFER_INFO) error { +func (h *windowsAnsiEventHandler) scroll(param int, sr scrollRegion, info *CONSOLE_SCREEN_BUFFER_INFO) error { logger.Infof("scroll: scrollTop: %d, scrollBottom: %d", sr.top, sr.bottom) logger.Infof("scroll: windowTop: %d, windowBottom: %d", info.Window.Top, info.Window.Bottom) @@ -64,7 +64,7 @@ func (h *WindowsAnsiEventHandler) scroll(param int, sr scrollRegion, info *CONSO // Origin to which area should be copied destOrigin := COORD{ X: 0, - Y: sr.top - SHORT(param), + Y: sr.top - int16(param), } char := CHAR_INFO{ @@ -78,7 +78,7 @@ func (h *WindowsAnsiEventHandler) scroll(param int, sr scrollRegion, info *CONSO return nil } -func (h *WindowsAnsiEventHandler) deleteCharacters(param int) error { +func (h *windowsAnsiEventHandler) deleteCharacters(param int) error { info, err := GetConsoleScreenBufferInfo(h.fd) if err != nil { return err @@ -86,12 +86,12 @@ func (h *WindowsAnsiEventHandler) deleteCharacters(param int) error { return h.scrollLine(param, info.CursorPosition, info) } -func (h *WindowsAnsiEventHandler) insertCharacters(param int) error { +func (h *windowsAnsiEventHandler) insertCharacters(param int) error { return h.deleteCharacters(-param) } // scrollLine scrolls a line horizontally starting at the provided position by a number of columns. -func (h *WindowsAnsiEventHandler) scrollLine(columns int, position COORD, info *CONSOLE_SCREEN_BUFFER_INFO) error { +func (h *windowsAnsiEventHandler) scrollLine(columns int, position COORD, info *CONSOLE_SCREEN_BUFFER_INFO) error { // Copy from and clip to the scroll region (full buffer width) scrollRect := SMALL_RECT{ Top: position.Y, @@ -102,7 +102,7 @@ func (h *WindowsAnsiEventHandler) scrollLine(columns int, position COORD, info * // Origin to which area should be copied destOrigin := COORD{ - X: position.X - SHORT(columns), + X: position.X - int16(columns), Y: position.Y, } diff --git a/winterm/utilities.go b/winterm/utilities.go index 2f963ff..afa7635 100644 --- a/winterm/utilities.go +++ b/winterm/utilities.go @@ -4,6 +4,6 @@ package winterm // AddInRange increments a value by the passed quantity while ensuring the values // always remain within the supplied min / max range. -func AddInRange(n SHORT, increment SHORT, min SHORT, max SHORT) SHORT { +func addInRange(n int16, increment int16, min int16, max int16) int16 { return ensureInRange(n+increment, min, max) } diff --git a/winterm/win_event_handler.go b/winterm/win_event_handler.go index 2d492b3..4d858ed 100644 --- a/winterm/win_event_handler.go +++ b/winterm/win_event_handler.go @@ -8,19 +8,19 @@ import ( "os" "strconv" - . "github.com/Azure/go-ansiterm" + "github.com/Azure/go-ansiterm" "github.com/Sirupsen/logrus" ) var logger *logrus.Logger -type WindowsAnsiEventHandler struct { +type windowsAnsiEventHandler struct { fd uintptr file *os.File infoReset *CONSOLE_SCREEN_BUFFER_INFO sr scrollRegion buffer bytes.Buffer - attributes WORD + attributes uint16 inverted bool wrapNext bool drewMarginByte bool @@ -30,10 +30,10 @@ type WindowsAnsiEventHandler struct { curPos COORD } -func CreateWinEventHandler(fd uintptr, file *os.File) AnsiEventHandler { +func CreateWinEventHandler(fd uintptr, file *os.File) ansiterm.AnsiEventHandler { logFile := ioutil.Discard - if isDebugEnv := os.Getenv(LogEnv); isDebugEnv == "1" { + if isDebugEnv := os.Getenv(ansiterm.LogEnv); isDebugEnv == "1" { logFile, _ = os.Create("winEventHandler.log") } @@ -48,7 +48,7 @@ func CreateWinEventHandler(fd uintptr, file *os.File) AnsiEventHandler { return nil } - return &WindowsAnsiEventHandler{ + return &windowsAnsiEventHandler{ fd: fd, file: file, infoReset: infoReset, @@ -57,8 +57,8 @@ func CreateWinEventHandler(fd uintptr, file *os.File) AnsiEventHandler { } type scrollRegion struct { - top SHORT - bottom SHORT + top int16 + bottom int16 } // simulateLF simulates a LF or CR+LF by scrolling if necessary to handle the @@ -68,7 +68,7 @@ type scrollRegion struct { // // In the false case, the caller should ensure that a carriage return // and line feed are inserted or that the text is otherwise wrapped. -func (h *WindowsAnsiEventHandler) simulateLF(includeCR bool) (bool, error) { +func (h *windowsAnsiEventHandler) simulateLF(includeCR bool) (bool, error) { if h.wrapNext { if err := h.Flush(); err != nil { return false, err @@ -89,24 +89,25 @@ func (h *WindowsAnsiEventHandler) simulateLF(includeCR bool) (bool, error) { h.updatePos(pos) } return false, nil - } else { - // A custom scroll region is active. Scroll the window manually to simulate - // the LF. - if err := h.Flush(); err != nil { - return false, err - } - logger.Info("Simulating LF inside scroll region") - if err := h.scrollUp(1); err != nil { + } + + // A custom scroll region is active. Scroll the window manually to simulate + // the LF. + if err := h.Flush(); err != nil { + return false, err + } + logger.Info("Simulating LF inside scroll region") + if err := h.scrollUp(1); err != nil { + return false, err + } + if includeCR { + pos.X = 0 + if err := SetConsoleCursorPosition(h.fd, pos); err != nil { return false, err } - if includeCR { - pos.X = 0 - if err := SetConsoleCursorPosition(h.fd, pos); err != nil { - return false, err - } - } - return true, nil } + return true, nil + } else if pos.Y < info.Window.Bottom { // Let Windows handle the LF. pos.Y++ @@ -133,7 +134,7 @@ func (h *WindowsAnsiEventHandler) simulateLF(includeCR bool) (bool, error) { } // executeLF executes a LF without a CR. -func (h *WindowsAnsiEventHandler) executeLF() error { +func (h *windowsAnsiEventHandler) executeLF() error { handled, err := h.simulateLF(false) if err != nil { return err @@ -145,7 +146,7 @@ func (h *WindowsAnsiEventHandler) executeLF() error { if err != nil { return err } - h.buffer.WriteByte(ANSI_LINE_FEED) + h.buffer.WriteByte(ansiterm.ANSI_LINE_FEED) if pos.X != 0 { if err := h.Flush(); err != nil { return err @@ -159,7 +160,7 @@ func (h *WindowsAnsiEventHandler) executeLF() error { return nil } -func (h *WindowsAnsiEventHandler) Print(b byte) error { +func (h *windowsAnsiEventHandler) Print(b byte) error { if h.wrapNext { h.buffer.WriteByte(h.marginByte) h.clearWrap() @@ -182,9 +183,9 @@ func (h *WindowsAnsiEventHandler) Print(b byte) error { return nil } -func (h *WindowsAnsiEventHandler) Execute(b byte) error { +func (h *windowsAnsiEventHandler) Execute(b byte) error { switch b { - case ANSI_TAB: + case ansiterm.ANSI_TAB: logger.Info("Execute(TAB)") // Move to the next tab stop, but preserve auto-wrap if already set. if !h.wrapNext { @@ -205,11 +206,11 @@ func (h *WindowsAnsiEventHandler) Execute(b byte) error { } return nil - case ANSI_BEL: - h.buffer.WriteByte(ANSI_BEL) + case ansiterm.ANSI_BEL: + h.buffer.WriteByte(ansiterm.ANSI_BEL) return nil - case ANSI_BACKSPACE: + case ansiterm.ANSI_BACKSPACE: if h.wrapNext { if err := h.Flush(); err != nil { return err @@ -223,15 +224,15 @@ func (h *WindowsAnsiEventHandler) Execute(b byte) error { if pos.X > 0 { pos.X-- h.updatePos(pos) - h.buffer.WriteByte(ANSI_BACKSPACE) + h.buffer.WriteByte(ansiterm.ANSI_BACKSPACE) } return nil - case ANSI_VERTICAL_TAB, ANSI_FORM_FEED: + case ansiterm.ANSI_VERTICAL_TAB, ansiterm.ANSI_FORM_FEED: // Treat as true LF. return h.executeLF() - case ANSI_LINE_FEED: + case ansiterm.ANSI_LINE_FEED: // Simulate a CR and LF for now since there is no way in go-ansiterm // to tell if the LF should include CR (and more things break when it's // missing than when it's incorrectly added). @@ -239,9 +240,9 @@ func (h *WindowsAnsiEventHandler) Execute(b byte) error { if handled || err != nil { return err } - return h.buffer.WriteByte(ANSI_LINE_FEED) + return h.buffer.WriteByte(ansiterm.ANSI_LINE_FEED) - case ANSI_CARRIAGE_RETURN: + case ansiterm.ANSI_CARRIAGE_RETURN: if h.wrapNext { if err := h.Flush(); err != nil { return err @@ -255,7 +256,7 @@ func (h *WindowsAnsiEventHandler) Execute(b byte) error { if pos.X != 0 { pos.X = 0 h.updatePos(pos) - h.buffer.WriteByte(ANSI_CARRIAGE_RETURN) + h.buffer.WriteByte(ansiterm.ANSI_CARRIAGE_RETURN) } return nil @@ -264,7 +265,7 @@ func (h *WindowsAnsiEventHandler) Execute(b byte) error { } } -func (h *WindowsAnsiEventHandler) CUU(param int) error { +func (h *windowsAnsiEventHandler) CUU(param int) error { if err := h.Flush(); err != nil { return err } @@ -273,7 +274,7 @@ func (h *WindowsAnsiEventHandler) CUU(param int) error { return h.moveCursorVertical(-param) } -func (h *WindowsAnsiEventHandler) CUD(param int) error { +func (h *windowsAnsiEventHandler) CUD(param int) error { if err := h.Flush(); err != nil { return err } @@ -282,7 +283,7 @@ func (h *WindowsAnsiEventHandler) CUD(param int) error { return h.moveCursorVertical(param) } -func (h *WindowsAnsiEventHandler) CUF(param int) error { +func (h *windowsAnsiEventHandler) CUF(param int) error { if err := h.Flush(); err != nil { return err } @@ -291,7 +292,7 @@ func (h *WindowsAnsiEventHandler) CUF(param int) error { return h.moveCursorHorizontal(param) } -func (h *WindowsAnsiEventHandler) CUB(param int) error { +func (h *windowsAnsiEventHandler) CUB(param int) error { if err := h.Flush(); err != nil { return err } @@ -300,7 +301,7 @@ func (h *WindowsAnsiEventHandler) CUB(param int) error { return h.moveCursorHorizontal(-param) } -func (h *WindowsAnsiEventHandler) CNL(param int) error { +func (h *windowsAnsiEventHandler) CNL(param int) error { if err := h.Flush(); err != nil { return err } @@ -309,7 +310,7 @@ func (h *WindowsAnsiEventHandler) CNL(param int) error { return h.moveCursorLine(param) } -func (h *WindowsAnsiEventHandler) CPL(param int) error { +func (h *windowsAnsiEventHandler) CPL(param int) error { if err := h.Flush(); err != nil { return err } @@ -318,7 +319,7 @@ func (h *WindowsAnsiEventHandler) CPL(param int) error { return h.moveCursorLine(-param) } -func (h *WindowsAnsiEventHandler) CHA(param int) error { +func (h *windowsAnsiEventHandler) CHA(param int) error { if err := h.Flush(); err != nil { return err } @@ -327,7 +328,7 @@ func (h *WindowsAnsiEventHandler) CHA(param int) error { return h.moveCursorColumn(param) } -func (h *WindowsAnsiEventHandler) VPA(param int) error { +func (h *windowsAnsiEventHandler) VPA(param int) error { if err := h.Flush(); err != nil { return err } @@ -339,11 +340,11 @@ func (h *WindowsAnsiEventHandler) VPA(param int) error { } window := h.getCursorWindow(info) position := info.CursorPosition - position.Y = window.Top + SHORT(param) - 1 + position.Y = window.Top + int16(param) - 1 return h.setCursorPosition(position, window) } -func (h *WindowsAnsiEventHandler) CUP(row int, col int) error { +func (h *windowsAnsiEventHandler) CUP(row int, col int) error { if err := h.Flush(); err != nil { return err } @@ -355,11 +356,11 @@ func (h *WindowsAnsiEventHandler) CUP(row int, col int) error { } window := h.getCursorWindow(info) - position := COORD{window.Left + SHORT(col) - 1, window.Top + SHORT(row) - 1} + position := COORD{window.Left + int16(col) - 1, window.Top + int16(row) - 1} return h.setCursorPosition(position, window) } -func (h *WindowsAnsiEventHandler) HVP(row int, col int) error { +func (h *windowsAnsiEventHandler) HVP(row int, col int) error { if err := h.Flush(); err != nil { return err } @@ -368,7 +369,7 @@ func (h *WindowsAnsiEventHandler) HVP(row int, col int) error { return h.CUP(row, col) } -func (h *WindowsAnsiEventHandler) DECTCEM(visible bool) error { +func (h *windowsAnsiEventHandler) DECTCEM(visible bool) error { if err := h.Flush(); err != nil { return err } @@ -377,7 +378,7 @@ func (h *WindowsAnsiEventHandler) DECTCEM(visible bool) error { return nil } -func (h *WindowsAnsiEventHandler) DECOM(enable bool) error { +func (h *windowsAnsiEventHandler) DECOM(enable bool) error { if err := h.Flush(); err != nil { return err } @@ -387,7 +388,7 @@ func (h *WindowsAnsiEventHandler) DECOM(enable bool) error { return h.CUP(1, 1) } -func (h *WindowsAnsiEventHandler) DECCOLM(use132 bool) error { +func (h *windowsAnsiEventHandler) DECCOLM(use132 bool) error { if err := h.Flush(); err != nil { return err } @@ -400,7 +401,7 @@ func (h *WindowsAnsiEventHandler) DECCOLM(use132 bool) error { if err != nil { return err } - targetWidth := SHORT(80) + targetWidth := int16(80) if use132 { targetWidth = 132 } @@ -426,7 +427,7 @@ func (h *WindowsAnsiEventHandler) DECCOLM(use132 bool) error { return SetConsoleCursorPosition(h.fd, COORD{0, 0}) } -func (h *WindowsAnsiEventHandler) ED(param int) error { +func (h *windowsAnsiEventHandler) ED(param int) error { if err := h.Flush(); err != nil { return err } @@ -485,7 +486,7 @@ func (h *WindowsAnsiEventHandler) ED(param int) error { return nil } -func (h *WindowsAnsiEventHandler) EL(param int) error { +func (h *windowsAnsiEventHandler) EL(param int) error { if err := h.Flush(); err != nil { return err } @@ -526,7 +527,7 @@ func (h *WindowsAnsiEventHandler) EL(param int) error { return nil } -func (h *WindowsAnsiEventHandler) IL(param int) error { +func (h *windowsAnsiEventHandler) IL(param int) error { if err := h.Flush(); err != nil { return err } @@ -535,7 +536,7 @@ func (h *WindowsAnsiEventHandler) IL(param int) error { return h.insertLines(param) } -func (h *WindowsAnsiEventHandler) DL(param int) error { +func (h *windowsAnsiEventHandler) DL(param int) error { if err := h.Flush(); err != nil { return err } @@ -544,7 +545,7 @@ func (h *WindowsAnsiEventHandler) DL(param int) error { return h.deleteLines(param) } -func (h *WindowsAnsiEventHandler) ICH(param int) error { +func (h *windowsAnsiEventHandler) ICH(param int) error { if err := h.Flush(); err != nil { return err } @@ -553,7 +554,7 @@ func (h *WindowsAnsiEventHandler) ICH(param int) error { return h.insertCharacters(param) } -func (h *WindowsAnsiEventHandler) DCH(param int) error { +func (h *windowsAnsiEventHandler) DCH(param int) error { if err := h.Flush(); err != nil { return err } @@ -562,7 +563,7 @@ func (h *WindowsAnsiEventHandler) DCH(param int) error { return h.deleteCharacters(param) } -func (h *WindowsAnsiEventHandler) SGR(params []int) error { +func (h *windowsAnsiEventHandler) SGR(params []int) error { if err := h.Flush(); err != nil { return err } @@ -579,13 +580,13 @@ func (h *WindowsAnsiEventHandler) SGR(params []int) error { } else { for _, attr := range params { - if attr == ANSI_SGR_RESET { + if attr == ansiterm.ANSI_SGR_RESET { h.attributes = h.infoReset.Attributes h.inverted = false continue } - h.attributes, h.inverted = collectAnsiIntoWindowsAttributes(h.attributes, h.inverted, h.infoReset.Attributes, SHORT(attr)) + h.attributes, h.inverted = collectAnsiIntoWindowsAttributes(h.attributes, h.inverted, h.infoReset.Attributes, int16(attr)) } } @@ -601,7 +602,7 @@ func (h *WindowsAnsiEventHandler) SGR(params []int) error { return nil } -func (h *WindowsAnsiEventHandler) SU(param int) error { +func (h *windowsAnsiEventHandler) SU(param int) error { if err := h.Flush(); err != nil { return err } @@ -610,7 +611,7 @@ func (h *WindowsAnsiEventHandler) SU(param int) error { return h.scrollUp(param) } -func (h *WindowsAnsiEventHandler) SD(param int) error { +func (h *windowsAnsiEventHandler) SD(param int) error { if err := h.Flush(); err != nil { return err } @@ -619,29 +620,29 @@ func (h *WindowsAnsiEventHandler) SD(param int) error { return h.scrollDown(param) } -func (h *WindowsAnsiEventHandler) DA(params []string) error { +func (h *windowsAnsiEventHandler) DA(params []string) error { logger.Infof("DA: [%v]", params) // DA cannot be implemented because it must send data on the VT100 input stream, // which is not available to go-ansiterm. return nil } -func (h *WindowsAnsiEventHandler) DECSTBM(top int, bottom int) error { +func (h *windowsAnsiEventHandler) DECSTBM(top int, bottom int) error { if err := h.Flush(); err != nil { return err } logger.Infof("DECSTBM: [%d, %d]", top, bottom) // Windows is 0 indexed, Linux is 1 indexed - h.sr.top = SHORT(top - 1) - h.sr.bottom = SHORT(bottom - 1) + h.sr.top = int16(top - 1) + h.sr.bottom = int16(bottom - 1) // This command also moves the cursor to the origin. h.clearWrap() return h.CUP(1, 1) } -func (h *WindowsAnsiEventHandler) RI() error { +func (h *windowsAnsiEventHandler) RI() error { if err := h.Flush(); err != nil { return err } @@ -656,17 +657,17 @@ func (h *WindowsAnsiEventHandler) RI() error { sr := h.effectiveSr(info.Window) if info.CursorPosition.Y == sr.top { return h.scrollDown(1) - } else { - return h.moveCursorVertical(-1) } + + return h.moveCursorVertical(-1) } -func (h *WindowsAnsiEventHandler) IND() error { +func (h *windowsAnsiEventHandler) IND() error { logger.Info("IND: []") return h.executeLF() } -func (h *WindowsAnsiEventHandler) Flush() error { +func (h *windowsAnsiEventHandler) Flush() error { h.curInfo = nil if h.buffer.Len() > 0 { logger.Infof("Flush: [%s]", h.buffer.Bytes()) @@ -683,7 +684,7 @@ func (h *WindowsAnsiEventHandler) Flush() error { return err } - charInfo := []CHAR_INFO{{UnicodeChar: WCHAR(h.marginByte), Attributes: info.Attributes}} + charInfo := []CHAR_INFO{{UnicodeChar: uint16(h.marginByte), Attributes: info.Attributes}} size := COORD{1, 1} position := COORD{0, 0} region := SMALL_RECT{Left: info.CursorPosition.X, Top: info.CursorPosition.Y, Right: info.CursorPosition.X, Bottom: info.CursorPosition.Y} @@ -697,7 +698,7 @@ func (h *WindowsAnsiEventHandler) Flush() error { // cacheConsoleInfo ensures that the current console screen information has been queried // since the last call to Flush(). It must be called before accessing h.curInfo or h.curPos. -func (h *WindowsAnsiEventHandler) getCurrentInfo() (COORD, *CONSOLE_SCREEN_BUFFER_INFO, error) { +func (h *windowsAnsiEventHandler) getCurrentInfo() (COORD, *CONSOLE_SCREEN_BUFFER_INFO, error) { if h.curInfo == nil { info, err := GetConsoleScreenBufferInfo(h.fd) if err != nil { @@ -709,7 +710,7 @@ func (h *WindowsAnsiEventHandler) getCurrentInfo() (COORD, *CONSOLE_SCREEN_BUFFE return h.curPos, h.curInfo, nil } -func (h *WindowsAnsiEventHandler) updatePos(pos COORD) { +func (h *windowsAnsiEventHandler) updatePos(pos COORD) { if h.curInfo == nil { panic("failed to call getCurrentInfo before calling updatePos") } @@ -719,7 +720,7 @@ func (h *WindowsAnsiEventHandler) updatePos(pos COORD) { // clearWrap clears the state where the cursor is in the margin // waiting for the next character before wrapping the line. This must // be done before most operations that act on the cursor. -func (h *WindowsAnsiEventHandler) clearWrap() { +func (h *windowsAnsiEventHandler) clearWrap() { h.wrapNext = false h.drewMarginByte = false }