# Copyright 2018-2024 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

load_lib gdb-python.exp

# Test CLI output styling.

standard_testfile

# Compile the test executable.
if {[build_executable "failed to build" $testfile $srcfile {debug macros}]} {
    return -1
}

# The tests in this file are run multiple times with GDB's styles
# disabled one at a time.  This variable is the style that is
# currently disabled.
set currently_disabled_style ""

# A wrapper around the 'style' function found in gdb-utils.exp,
# filter out requests for the disabled style.
proc limited_style { str style } {
    global currently_disabled_style

    if { $style != $currently_disabled_style } {
	return [style $str $style]
    }

    return $str
}

# A wrapper around 'clean_restart' from gdb.exp, this performs the
# normal clean_restart, but then disables the currently disabled
# style.
proc clean_restart_and_disable { prefix args } {
    global currently_disabled_style

    with_test_prefix "$prefix" {
	eval "clean_restart $args"

	if { $currently_disabled_style != "" } {
	    set st $currently_disabled_style
	    gdb_test_no_output "set style $st background none"
	    gdb_test_no_output "set style $st foreground none"
	    gdb_test_no_output "set style $st intensity normal"
	}
    }
}

# The core of this test script.  Run some tests of different aspects
# of GDB's styling.
#
# Within this proc always use LIMITED_STYLE instead of STYLE, and
# CLEAN_RESTART_AND_DISABLE instead of CLEAN_RESTART, this ensures
# that the test operates as expected as styles are disabled.
proc run_style_tests { } {
    global testfile srcfile hex binfile
    global currently_disabled_style decimal hex

    with_ansi_styling_terminal {
	# Restart GDB with the correct TERM variable setting, this
	# means that GDB will enable styling.
	clean_restart_and_disable "restart 1" ${binfile}

	set readnow [readnow]

	if {![runto_main]} {
	    return
	}

	# Check that the source highlighter has not stripped away the
	# leading newlines.
	set main_line [gdb_get_line_number "break here"]
	gdb_test "list $main_line,$main_line" "return.*some_called_function.*"

	gdb_test_no_output "set style enabled off"

	set argv ""
	gdb_test_multiple "frame" "frame without styling" {
	    -re -wrap "main \\(argc=.*, (argv=$hex.*)\\).*style\\.c:\[0-9\].*" {
		set argv $expect_out(1,string)
		pass $gdb_test_name
	    }
	}

	gdb_test_no_output "set style enabled on"

	set main_expr [limited_style main function]
	set base_file_expr [limited_style ".*style\\.c" file]
	set line_expr [limited_style $decimal line-number]
	set file_expr "$base_file_expr:$line_expr"
	set arg_expr [limited_style "arg." variable]

	# On some embedded targets that don't fully support argc/argv,
	# argv may print as "0x0" or as an address with a symbol name
	# following, so use a regexp general enough to match that and
	# do not make assumptions about how long the address string is.
	gdb_test "frame" \
	    [multi_line \
		 "#0\\s+$main_expr\\s+\\($arg_expr=$decimal,\\s+$arg_expr=$hex.*\\)\\s+at\\s+$file_expr" \
		 "$line_expr\\s+.*return.* break here .*"]
	gdb_test "info breakpoints" \
	    ".*[limited_style What title].*$main_expr at $file_expr.*"

	gdb_test_no_output "set style sources off"
	gdb_test "frame" \
	    "\r\n$line_expr\[^\033\]*break here.*" \
	    "frame without sources styling"
	gdb_test_no_output "set style sources on"

	gdb_test "break -q main" "file $base_file_expr.*"

	gdb_test "print &main" " = .* [limited_style $hex address] <$main_expr>"

	# Regression test for a bug where line-wrapping would occur at
	# the wrong spot with styling.  There were different bugs at
	# different widths, so try two.
	foreach width {20 30} {
	    set argv_len [string length $argv]
	    if { $argv_len == 0 } {
		continue
	    }

	    # There was also a bug where the styling could be wrong in
	    # the line listing; this is why the words from the source
	    # code are spelled out in the final result line of the
	    # test.
	    set re0_styled \
		[multi_line \
		     "#0\\s+$main_expr\\s+\\($arg_expr=$decimal,\\s+$arg_expr=$hex\\)" \
		     "\\s+at\\s+$file_expr" \
		     "$line_expr\\s+.*return.* break here .*"]
	    set re1_styled \
		[multi_line \
		     "#0\\s+$main_expr\\s+\\($arg_expr=$decimal,\\s+" \
		     "\\s+$arg_expr=$hex.*\\)" \
		     "\\s+at\\s+$file_expr" \
		     "$line_expr\\s+.*return.* break here .*"]
	    set re2_styled \
		[multi_line \
		     "#0\\s+$main_expr\\s+\\($arg_expr=.*" \
		     "\\s+$arg_expr=$hex.*\\)\\s+at\\s+$file_expr" \
		     "$line_expr\\s+.*return.* break here .*"]

	    # The length of the line containing argv containing:
	    # - 4 leading spaces
	    # - argv string
	    # - closing parenthesis
	    set line_len [expr 4 + $argv_len + 1]

	    if { $argv == "argv=0x0" && $width >= 27 } {
		# Embedded target with no argv support.
		# #0  main (argc=0, argv=0x0)
		set re_styled $re0_styled
	    } elseif { $line_len > $width } {
		# At on the next line.
		set re_styled $re1_styled
	    } else {
		# At on the same line as argv.
		set re_styled $re2_styled
	    }

	    # Override width for the duration of the command, letting
	    # GDB reset back to 0.  Doing this in the loop rather than
	    # after, avoids trying to do "set width 30" while width is
	    # 20, which causes horizontal scrolling in the case that
	    # the fallback stub-termcap.c is used:
	    # ^M<et width 30^M
	    # (gdb) FAIL: gdb.base/style.exp: all styles enabled: set width 30
	    gdb_test "with width $width -- frame" $re_styled \
		"frame when width=$width"
	}

	set macro_line [gdb_get_line_number "\#define SOME_MACRO"]
	gdb_test "info macro SOME_MACRO" \
	    "Defined at $base_file_expr:$macro_line\r\n#define SOME_MACRO 23"

	gdb_test_no_output "set width 0"

	# If disassembler styling is being done by the Python pygments
	# module, then we can't be sure how the 'some_called_function'
	# symbol will be styled.  However, if pygments is not being
	# used then we can know how the symbol name will be styled.
	set main [limited_style main function]
	if { $::python_disassembly_styling } {
	    set func "some_called_function"
	} else {
	    set func [limited_style some_called_function function]
	}
	# Somewhere should see the call to the function.
	gdb_test "disassemble main" \
	    [concat "Dump of assembler code for function $main:.*" \
		 "[limited_style $hex address].*$func.*"]

	set ifield [limited_style int_field variable]
	set sfield [limited_style string_field variable]
	set efield [limited_style e_field variable]
	set evalue [limited_style VALUE_TWO variable]
	set lhs [limited_style "\\\$$decimal" variable]
	gdb_test "print struct_value" \
	    "$lhs = \{$ifield = 23,.*$sfield = .*,.*$efield = $evalue.*"

	set ffield [limited_style field variable]
	set cstart [string_to_regexp "/* XXX "]
	set cend [string_to_regexp " */"]
	set p1field [limited_style "$cstart.*$decimal.*-bit.*padding.*$cend" \
			 highlight]
	set p2field [limited_style "$cstart.*$decimal.*-byte.*padding.*$cend" \
			 highlight]

	gdb_test "ptype/o just_bitfield_value" \
	    [multi_line \
		 ".* type = struct just_bitfield {" \
		 ".* unsigned int $ffield : 3;" \
		 "$p1field" \
		 "$p2field" \
		 "" \
		 ".* total size.*: *$decimal *$cend" \
		 " *}.*"]

	set address_style_expr [limited_style ".*\".*address.*\".*style.*" address]
	set color "blue"
	if { $currently_disabled_style == "address" } {
	    set color "none"
	}
	gdb_test "show style address foreground" \
	    "The ${address_style_expr} foreground color is: ${color}" \
	    "style name and style word styled using its own style in show style"

	set aliases_expr [limited_style ".*aliases.*" command]
	set breakpoints_expr [limited_style ".*breakpoints.*" command]
	gdb_test "help" \
	    [multi_line \
		 "List of classes of commands:" \
		 "" \
		 "${aliases_expr} -- User-defined aliases of other commands\." \
		 "${breakpoints_expr} -- Making program stop at certain points\." \
		 ".*" \
		] \
	    "help classes of commands styled with command"

	set taas_expr  [limited_style ".*taas.*" command]
	set tfaas_expr  [limited_style ".*tfaas.*" command]
	set cut_for_thre_expr [limited_style "cut for 'thre" highlight]
	gdb_test "apropos -v cut for 'thre" \
	    [multi_line \
		 "" \
		 "${taas_expr}" \
		 "Apply a command to all .*" \
		 "Usage:.*" \
		 "short${cut_for_thre_expr}ad apply.*" \
		 "" \
		 "${tfaas_expr}" \
		 "Apply a command to all .*" \
		 "Usage:.*" \
		 "short${cut_for_thre_expr}ad apply.*" \
		]

	clean_restart_and_disable "restart 2"

	set quoted [string_to_regexp $binfile]
	set pass_re "Reading symbols from [limited_style $quoted file]\.\.\."
	if { $readnow } {
	    set pass_re \
		[multi_line \
		     $pass_re \
		     "Expanding full symbols from [limited_style $quoted file]\.\.\."]
	}
	gdb_test "file $binfile" \
	    $pass_re \
	    "filename is styled when loading symbol file"

	gdb_test "pwd" "Working directory [limited_style .*? file].*"

	gdb_test_no_output "set print repeat 3"
	gdb_test "print {0,0,0,0,0,0,0,0}" \
	    " = \\{0 [limited_style {<repeats.*8.*times>} metadata]\\}"

	gdb_test "show logging file" \
	    "The current logfile is \"[limited_style .*? file]\"\\..*"

	# Check warnings are styled by setting a rubbish data
	# directory.
	gdb_test "set data-directory Makefile" \
	    "warning: [limited_style .*? file] is not a directory\\..*"
	gdb_test "show data-directory" \
	    "GDB's data directory is \"[limited_style .*? file]\"\\..*"

	# Check that deprecation styles command names.
	gdb_test_no_output "maintenance deprecate p \"new_p\"" \
	    "maintenance deprecate p \"new_p\" /1/"
	gdb_test "p 5" \
	    "Warning: '[limited_style p command]', an alias for the command '[limited_style print command]', is deprecated.*Use '[limited_style new_p command]'.*" \
	    "p deprecated warning, with replacement"

	# Check that the version string is styled in the output of 'show
	# version', and that this styling can be disabled.
	set vers [style "GNU gdb.*" version]
	set url [limited_style "http:.*html" file]
	gdb_test "show version" "${vers}.*<$url>.*" \
	    "'show version' is styled"
    }
}

# Check that disassembler styling can be disabled.  The function that
# we are disassembling has some minimal styling applied even if the
# Python pygments module is not available, so, when we disable
# disassembler styling, we should always see a change in output.
proc test_disable_disassembler_styling { } {
    save_vars { env(TERM) env(NO_COLOR) } {
	# We need an ANSI-capable terminal to get the output.
	setenv TERM ansi
	setenv NO_COLOR ""

	# Restart GDB with the correct TERM variable setting, this
	# means that GDB will enable styling.
	clean_restart_and_disable "restart 3" $::binfile

	set styled_hex [limited_style $::hex address]
	set main [limited_style main function]

	foreach_with_prefix libopcodes { on off } {

	    set command_failed false
	    gdb_test_multiple "maint set libopcodes-styling enabled ${libopcodes}" "" {
		-re "^maint set libopcodes-styling enabled ${libopcodes}\r\n" {
		    exp_continue
		}

		-re "Use of libopcodes styling not supported on architecture \[^\r\n\]+\r\n" {
		    set command_failed true
		    exp_continue
		}

		-re "^$::gdb_prompt $" {
		    gdb_assert { !$command_failed || [string equal $libopcodes "on"] } \
			$gdb_test_name
		}
	    }

	    if { $libopcodes == "on" && $command_failed } {
		# We tried to turn on libopcodes disassembler styling,
		# but this is not supported on this architecture.
		continue
	    }

	    foreach_with_prefix disasm_styling { on off } {
		gdb_test_no_output "set style disassembler enabled ${disasm_styling}"

		if { $libopcodes == "off" && $disasm_styling == "on" \
			 && !$::python_disassembly_styling} {
		    # We have libopcodes based styling off, but
		    # disassembler styling turned on.  We're expecting
		    # Python Pygments to be used to add styling.
		    #
		    # However, if we get here, then we don't have the
		    # Pygments module, so skip this test.
		    continue
		}

		set saw_header_line false
		set saw_styled_output_line false
		set saw_unstyled_output_line false
		gdb_test_multiple "disassemble main" "" {
		    -re "disassemble main\r\n" {
			exp_continue
		    }
		    -re "^Dump of assembler code for function $main:" {
			set saw_header_line true
			exp_continue
		    }
		    -re "^\\s+${styled_hex}\\s+<\[^>\]+>:\\s+\[^\r\n\033\]+\r\n" {
			set saw_unstyled_output_line true
			exp_continue
		    }
		    -re "^\\s+${styled_hex}\\s+<\[^>\]+>:\\s+\[^\r\n\]+\033\[^\r\n\]+\r\n" {
			set saw_styled_output_line true
			exp_continue
		    }
		    -re "^End of assembler dump\\.\r\n" {
			exp_continue
		    }
		    -re "^$::gdb_prompt $" {
			gdb_assert { $saw_header_line }
			if { $disasm_styling } {
			    gdb_assert { $saw_styled_output_line }
			    gdb_assert { !$saw_unstyled_output_line }
			} else {
			    gdb_assert { !$saw_styled_output_line }
			    gdb_assert { $saw_unstyled_output_line }
			}
		    }
		}
	    }
	}
    }
}

# Disassemble a single isntruction at the start of main, then strip
# off the address and symbol information, returning just the
# disassembled instruction part.
proc get_single_disassembled_insn {} {
    set disasm_line [capture_command_output "x/1i *main" ""]
    regexp "^\[^:\]+:\\s*(.*)$" $disasm_line whole_match insn
    return $insn
}

# Check that, if the user is using Python Pygments for disassembler
# styling, then the styling correctly switches off when an error is
# detected in the Python code.
proc test_disassembler_error_handling { } {

    # This test requires the Python Pygments module to be installed
    # and used by GDB.
    if { !$::python_disassembly_styling } {
	return
    }

    save_vars { env(TERM) env(NO_COLOR) } {
	# We need an ANSI-capable terminal to get the output.
	setenv TERM ansi
	setenv NO_COLOR ""

	# Restart GDB with the correct TERM variable setting, this
	# means that GDB will enable styling.
	clean_restart_and_disable "restart 4" $::binfile

	# Disable use of libopcodes for styling.  As this function is
	# only called when Python Pygments module is available, we
	# should now be using that module to style the disassembler
	# output.
	gdb_test_no_output "maint set libopcodes-styling enabled off"

	# Disassemble a single instruction and ensure that the output
	# has styling markers in it.
	set insn_before [get_single_disassembled_insn]
	gdb_assert { [regexp "\033" $insn_before] } \
	    "have style markers when Pygments is working fine"

	# Now replace the standard function that colorizes the
	# disassembler output, with a new function that always returns
	# None, this should cause GDB to stop using the Pygments
	# module for disassembler styling.
	gdb_py_test_silent_cmd \
	    [multi_line_input \
		 "python" \
		 "def replacement_colorize_disasm(content,gdbarch):" \
		 "  return None" \
		 "gdb.styling.colorize_disasm = replacement_colorize_disasm" \
		 "end"] \
	    "setup replacement colorize_disasm function" \
	    true

	set insn_after [get_single_disassembled_insn]
	gdb_assert { ![regexp "\033" $insn_after] } \
	    "have no style markers when Pygments is broken"
    }
}

# A separate test from the above as the styled text this checks can't
# currently be disabled (the text is printed too early in GDB's
# startup process).
proc test_startup_version_string { } {
    gdb_exit

    save_vars { ::INTERNAL_GDBFLAGS } {
	set ::INTERNAL_GDBFLAGS [string map {"-q" ""} $::INTERNAL_GDBFLAGS]

	gdb_spawn
    }

    # Deliberate use of base STYLE proc here as the style of the
    # startup version string can't (currently) be controlled.
    set vers [style "GNU gdb.*" version]
    gdb_test "" "${vers}.*" "version is styled at startup"
}

# Check to see if the Python styling of disassembler output is
# expected or not, this styling requires Python support in GDB, and
# the Python pygments module to be available.
clean_restart ${binfile}
if {[allow_python_tests] && [gdb_py_module_available "pygments"]} {
    set python_disassembly_styling true
} else {
    set python_disassembly_styling false
}

# Run tests with all styles in their default state.
with_test_prefix "all styles enabled" {
    run_style_tests
}

# Now, for each style in turn.  Disable that style only and run the
# test again.  Things in that style should NOT now be styled.
foreach style { command title file function highlight variable \
		    address metadata } {
    set currently_disabled_style $style
    with_test_prefix "disable style $style" {
	run_style_tests
    }
}

# Check that the disassembler styling can be disabled.
test_disable_disassembler_styling

# Check that GDB handles an error in the Python Pygments disassembly
# styling code.
test_disassembler_error_handling

# Finally, check the styling of the version string during startup.
test_startup_version_string
