diff --git a/CMakeLists.txt b/CMakeLists.txt
index 950b6b94..60450c72 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,122 +1,122 @@
cmake_minimum_required(VERSION 3.0)
-set(KF5_VERSION "5.41.0") # handled by release scripts
-set(KF5_DEP_VERSION "5.40.0") # handled by release scripts
+set(KF5_VERSION "5.42.0") # handled by release scripts
+set(KF5_DEP_VERSION "5.41.0") # handled by release scripts
project(KTextEditor VERSION ${KF5_VERSION})
# ECM setup
include(FeatureSummary)
-find_package(ECM 5.40.0 NO_MODULE)
+find_package(ECM 5.41.0 NO_MODULE)
set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules")
feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
# add own modules to search path, too
set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
include(ECMSetupVersion)
include(ECMGenerateHeaders)
include(CMakePackageConfigHelpers)
include(CheckFunctionExists)
include(CheckSymbolExists)
include(KDEInstallDirs)
include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
include(KDECMakeSettings)
include(KDEPackageAppTemplates)
include(GenerateExportHeader)
include(ECMAddQch)
option(BUILD_QCH "Build API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)" OFF)
add_feature_info(QCH ${BUILD_QCH} "API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)")
ecm_setup_version(
PROJECT
VARIABLE_PREFIX KTEXTEDITOR
VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/ktexteditor_version.h"
PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5TextEditorConfigVersion.cmake"
SOVERSION 5
)
# Dependencies
set(REQUIRED_QT_VERSION 5.7.0)
# Required Qt5 components to build this framework
find_package(Qt5 ${REQUIRED_QT_VERSION} NO_MODULE REQUIRED Core Widgets Qml
PrintSupport Xml XmlPatterns)
find_package(KF5Archive ${KF5_DEP_VERSION} REQUIRED)
find_package(KF5Config ${KF5_DEP_VERSION} REQUIRED)
find_package(KF5GuiAddons ${KF5_DEP_VERSION} REQUIRED)
find_package(KF5I18n ${KF5_DEP_VERSION} REQUIRED)
find_package(KF5KIO ${KF5_DEP_VERSION} REQUIRED)
find_package(KF5Parts ${KF5_DEP_VERSION} REQUIRED)
find_package(KF5Sonnet ${KF5_DEP_VERSION} REQUIRED)
find_package(KF5IconThemes ${KF5_DEP_VERSION} REQUIRED)
find_package(KF5SyntaxHighlighting ${KF5_DEP_VERSION} REQUIRED)
# libgit2 integration, at least 0.22 with proper git_libgit2_init()
find_package(LibGit2 "0.22.0")
# EditorConfig integration
find_package(EditorConfig)
# vi mode on per default
option (BUILD_VIMODE "Build vimode in" ON)
# Subdirectories
add_definitions(-DTRANSLATION_DOMAIN=\"ktexteditor5\")
if (IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/po")
ki18n_install(po)
endif()
add_subdirectory(src)
if (BUILD_TESTING)
add_subdirectory(autotests)
endif()
add_subdirectory(templates)
# Create a Config.cmake and a ConfigVersion.cmake file and install them
set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5TextEditor")
if (BUILD_QCH)
ecm_install_qch_export(
TARGETS KF5TextEditor_QCH
FILE KF5TextEditorQchTargets.cmake
DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
COMPONENT Devel
)
set(PACKAGE_INCLUDE_QCHTARGETS "include(\"\${CMAKE_CURRENT_LIST_DIR}/KF5TextEditorQchTargets.cmake\")")
endif()
configure_package_config_file(
"${CMAKE_CURRENT_SOURCE_DIR}/KF5TextEditorConfig.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/KF5TextEditorConfig.cmake"
INSTALL_DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
)
install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/KF5TextEditorConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/KF5TextEditorConfigVersion.cmake"
DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
COMPONENT Devel
)
install(EXPORT
KF5TextEditorTargets
DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
FILE KF5TextEditorTargets.cmake
NAMESPACE KF5::
)
install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/ktexteditor_version.h"
DESTINATION "${KDE_INSTALL_INCLUDEDIR_KF5}"
COMPONENT Devel
)
# config.h
check_symbol_exists (fdatasync unistd.h HAVE_FDATASYNC)
configure_file (config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h)
# let our config.h be found first in any case
include_directories (BEFORE ${CMAKE_CURRENT_BINARY_DIR})
feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/autotests/input/syntax/c/results/preprocessor-bug363280.c.reference.html b/autotests/input/syntax/c/results/preprocessor-bug363280.c.reference.html
index a83fecc9..37a07109 100644
--- a/autotests/input/syntax/c/results/preprocessor-bug363280.c.reference.html
+++ b/autotests/input/syntax/c/results/preprocessor-bug363280.c.reference.html
@@ -1,22 +1,22 @@
preprocessor-bug363280.c
-
+
#if 1
int x; // variable shall not be grey
#endif
#if defined (A)
int y; // variable shall not be grey
#elif defined (B)
int z; // variable shall not be grey
#endif
diff --git a/autotests/input/syntax/carto-css/results/test.mss.reference.html b/autotests/input/syntax/carto-css/results/test.mss.reference.html
index 0902fddf..e7601b9e 100644
--- a/autotests/input/syntax/carto-css/results/test.mss.reference.html
+++ b/autotests/input/syntax/carto-css/results/test.mss.reference.html
@@ -1,229 +1,229 @@
test.mss
-
+
/* kate: hl CartoCSS
This file contains some content coming from
https://github.com/gravitystorm/openstreetmap-carto
with CC0 license. This file is just for testing
katepart highlighting engine.
*/
#world {
// this syntax
polygon-opacity: 50%;
// is equivalent to
polygon-opacity: 0.5;
}
@admin-boundaries: #ac46ac;
/* For performance reasons, the admin border layers are split into three groups
for low, middle and high zoom levels.
For each zoomlevel, all borders come from a single attachment, to handle
overlapping borders correctly.
*/
#admin-low-zoom[zoom < 11], // test
#admin-mid-zoom[zoom >= 11][zoom < 13],
#admin-high-zoom[zoom >= 13] {
[admin_level = '2'],
[admin_level = '3'] {
[zoom >= 4] {
background/line-color: white;
background/line-width: 0.6;
line-color: @admin-boundaries;
line-width: 0.6;
}
[zoom >= 7] {
background/line-width: 2;
line-width: 2;
}
[zoom >= 10] {
[admin_level = '2'] {
background/line-width: 6;
line-width: 6;
}
[admin_level = '3'] {
background/line-width: 5;
line-width: 5;
line-dasharray: 4,2;
line-clip: false;
}
}
}
[admin_level = '4'] {
[zoom >= 4] {
background/line-color: white;
background/line-width: 0.6;
line-color: @admin-boundaries;
line-width: 0.6;
line-dasharray: 4,3;
line-clip: false;
}
[zoom >= 7] {
background/line-width: 1;
line-width: 1;
}
[zoom >= 11] {
background/line-width: 3;
line-width: 3;
}
}
/*
The following code prevents admin boundaries from being rendered on top of
each other. Comp-op works on the entire attachment, not on the individual
border. Therefore, this code generates an attachment containing a set of
@admin-boundaries/white dashed lines (of which only the top one is visible),
and with `comp-op: darken` the white part is ignored, while the
@admin-boundaries colored part is rendered (as long as the background is not
darker than @admin-boundaries).
The SQL has `ORDER BY admin_level`, so the boundary with the lowest
admin_level is rendered on top, and therefore the only visible boundary.
*/
opacity: 0.4;
comp-op: darken;
}
#admin-mid-zoom[zoom >= 11][zoom < 13],
#admin-high-zoom[zoom >= 13] {
[admin_level = '5'][zoom >= 11] {
background/line-color: white;
background/line-width: 2;
line-color: @admin-boundaries;
line-width: 2;
line-dasharray: 6,3,2,3,2,3;
line-clip: false;
}
[admin_level = '6'][zoom >= 11] {
background/line-color: white;
background/line-width: 2;
line-color: @admin-boundaries;
line-width: 2;
line-dasharray: 6,3,2,3;
line-clip: false;
}
[admin_level = '7'],
[admin_level = '8'] {
[zoom >= 12] {
background/line-color: white;
background/line-width: 1.5;
line-color: @admin-boundaries;
line-width: 1.5;
line-dasharray: 5,2;
line-clip: false;
}
}
opacity: 0.5;
comp-op: darken;
}
#admin-high-zoom[zoom >= 13] {
[admin_level = '9'],
[admin_level = '10'] {
[zoom >= 13] {
background/line-color: white;
background/line-width: 2;
line-color: @admin-boundaries;
line-width: 2;
line-dasharray: 2,3;
line-clip: false;
}
}
opacity: 0.5;
comp-op: darken;
}
#nature-reserve-boundaries {
[way_pixels > 100][zoom >= 7] {
[zoom < 10] {
::fill {
opacity: 0.05;
polygon-fill: green;
}
}
a/line-width: 1;
a/line-offset: -0.5;
a/line-color: green;
a/line-opacity: 0.15;
a/line-join: round;
a/line-cap: round;
b/line-width: 2;
b/line-offset: -1;
b/line-color: green;
b/line-opacity: 0.15;
b/line-join: round;
b/line-cap: round;
[zoom >= 10] {
a/line-width: 2;
a/line-offset: -1;
b/line-width: 4;
b/line-offset: -2;
}
[zoom >= 14] {
b/line-width: 6;
b/line-offset: -3;
}
}
}
#building-text {
[zoom >= 14][way_pixels > 3000],
[zoom >= 17] {
text-name: "[name]";
text-size: 11;
text-fill: #444;
text-face-name: @book-fonts;
text-halo-radius: 1;
text-wrap-width: 20;
text-halo-fill: rgba(255,255,255,0.5);
text-placement: interior;
}
}
@marina-text: #576ddf; // also swimming_pool
@landcover-face-name: @oblique-fonts;
@standard-wrap-width: 30;
.points {
[feature = 'tourism_alpine_hut'][zoom >= 13] {
point-file: url('symbols/alpinehut.p.16.png');
point-placement: interior;
}
}
[feature = 'highway_bus_stop'] {
[zoom >= 16] {
marker-file: url('symbols/square.svg');
marker-fill: @transportation-icon;
marker-placement: interior;
marker-width: 6;
}
[zoom >= 17] {
marker-file: url('symbols/bus_stop.p.12.png');
marker-width: 12;
}
}
[feature = 'highway_primary'] {
[zoom >= 7][zoom < 12] {
line-width: 0.5;
line-color: @primary-fill;
[zoom >= 9] { line-width: 1.2; }
[zoom >= 10] { line-width: 2; }
[zoom >= 11] { line-width: .5; }
}
}
diff --git a/autotests/input/syntax/cpp/results/preprocessor-bug363280.cpp.reference.html b/autotests/input/syntax/cpp/results/preprocessor-bug363280.cpp.reference.html
index 5c5e31de..9b25c373 100644
--- a/autotests/input/syntax/cpp/results/preprocessor-bug363280.cpp.reference.html
+++ b/autotests/input/syntax/cpp/results/preprocessor-bug363280.cpp.reference.html
@@ -1,22 +1,22 @@
preprocessor-bug363280.cpp
-
+
#if 1
int x; // variable shall not be grey
#endif
#if defined (A)
int y; // variable shall not be grey
#elif defined (B)
int z; // variable shall not be grey
#endif
diff --git a/autotests/input/syntax/dockerfile/results/Dockerfile.reference.html b/autotests/input/syntax/dockerfile/results/Dockerfile.reference.html
index 712faa7b..24cbcce8 100644
--- a/autotests/input/syntax/dockerfile/results/Dockerfile.reference.html
+++ b/autotests/input/syntax/dockerfile/results/Dockerfile.reference.html
@@ -1,33 +1,33 @@
Dockerfile
-
+
# LGPLv2+ example file
# This is a comment
FROM ubuntu:14.04
MAINTAINER James Turnbull <james@example.com> # comment
ENV REFRESHED_AT 2014-06-01
RUN apt-get -yqq update
RUN apt-get install -yqq software-properties-common python-software-properties
RUN add-apt-repository ppa:chris-lea/redis-server
RUN apt-get -yqq update
RUN apt-get -yqq install redis-server redis-tools
RUN apt-get -yqq update # comment
VOLUME [ "/var/lib/redis", "/var/log/redis/" ]
EXPOSE 6379
CMD []
diff --git a/autotests/input/syntax/elixir/results/hello.exs.reference.html b/autotests/input/syntax/elixir/results/hello.exs.reference.html
index 7d011b0a..ddab4c03 100644
--- a/autotests/input/syntax/elixir/results/hello.exs.reference.html
+++ b/autotests/input/syntax/elixir/results/hello.exs.reference.html
@@ -1,25 +1,25 @@
hello.exs
-
+
parent = self()
# Spawns an Elixir process (not an operating system one!)
spawn_link(fn ->
send parent, {:msg, "hello world"}
end)
# Block until the message is received
receive do
{:msg, contents} -> IO.puts contents
end
diff --git a/autotests/input/syntax/elixir/results/learnelixir.exs.reference.html b/autotests/input/syntax/elixir/results/learnelixir.exs.reference.html
index 8e3329ac..97e3ccec 100644
--- a/autotests/input/syntax/elixir/results/learnelixir.exs.reference.html
+++ b/autotests/input/syntax/elixir/results/learnelixir.exs.reference.html
@@ -1,411 +1,411 @@
learnelixir.exs
-
+
# Original: https://learnxinyminutes.com/docs/elixir/
# Single line comments start with a number symbol.
# There's no multi-line comment,
# but you can stack multiple comments.
# To use the elixir shell use the `iex` command.
# Compile your modules with the `elixirc` command.
# Both should be in your path if you installed elixir correctly.
## ---------------------------
## -- Basic types
## ---------------------------
# There are numbers
3 # integer
0x1F # integer
3.0 # float
# Atoms, that are literals, a constant with name. They start with `:`.
:hello # atom
# Tuples that are stored contiguously in memory.
{1,2,3} # tuple
# We can access a tuple element with the `elem` function:
elem({1, 2, 3}, 0) #=> 1
# Lists that are implemented as linked lists.
[1,2,3] # list
# We can access the head and tail of a list as follows:
[head | tail] = [1,2,3]
head #=> 1
tail #=> [2,3]
# In elixir, just like in Erlang, the `=` denotes pattern matching and
# not an assignment.
#
# This means that the left-hand side (pattern) is matched against a
# right-hand side.
#
# This is how the above example of accessing the head and tail of a list works.
# A pattern match will error when the sides don't match, in this example
# the tuples have different sizes.
# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
# There are also binaries
<<1,2,3>> # binary
# Strings and char lists
"hello" # string
'hello' # char list
# Multi-line strings
"""
I'm a multi-line
string.
"""
#=> "I'm a multi-line\nstring.\n"
# Strings are all encoded in UTF-8:
"héllò" #=> "héllò"
# Strings are really just binaries, and char lists are just lists.
<<?a, ?b, ?c>> #=> "abc"
[?a, ?b, ?c] #=> 'abc'
# `?a` in elixir returns the ASCII integer for the letter `a`
?a #=> 97
# To concatenate lists use `++`, for binaries use `<>`
[1,2,3] ++ [4,5] #=> [1,2,3,4,5]
'hello ' ++ 'world' #=> 'hello world'
<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
"hello " <> "world" #=> "hello world"
# Ranges are represented as `start..end` (both inclusive)
1..10 #=> 1..10
lower..upper = 1..10 # Can use pattern matching on ranges as well
[lower, upper] #=> [1, 10]
## ---------------------------
## -- Operators
## ---------------------------
# Some math
1 + 1 #=> 2
10 - 5 #=> 5
5 * 2 #=> 10
10 / 2 #=> 5.0
# In elixir the operator `/` always returns a float.
# To do integer division use `div`
div(10, 2) #=> 5
# To get the division remainder use `rem`
rem(10, 3) #=> 1
# There are also boolean operators: `or`, `and` and `not`.
# These operators expect a boolean as their first argument.
true and true #=> true
false or true #=> true
# 1 and true #=> ** (ArgumentError) argument error
# Elixir also provides `||`, `&&` and `!` which accept arguments of any type.
# All values except `false` and `nil` will evaluate to true.
1 || true #=> 1
false && 1 #=> false
nil && 20 #=> nil
!true #=> false
# For comparisons we have: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` and `>`
1 == 1 #=> true
1 != 1 #=> false
1 < 2 #=> true
# `===` and `!==` are more strict when comparing integers and floats:
1 == 1.0 #=> true
1 === 1.0 #=> false
# We can also compare two different data types:
1 < :hello #=> true
# The overall sorting order is defined below:
# number < atom < reference < functions < port < pid < tuple < list < bit string
# To quote Joe Armstrong on this: "The actual order is not important,
# but that a total ordering is well defined is important."
## ---------------------------
## -- Control Flow
## ---------------------------
# `if` expression
if false do
"This will never be seen"
else
"This will"
end
# There's also `unless`
unless true do
"This will never be seen"
else
"This will"
end
# Remember pattern matching? Many control-flow structures in elixir rely on it.
# `case` allows us to compare a value against many patterns:
case {:one, :two} do
{:four, :five} ->
"This won't match"
{:one, x} ->
"This will match and bind `x` to `:two`"
_ ->
"This will match any value"
end
# It's common to bind the value to `_` if we don't need it.
# For example, if only the head of a list matters to us:
[head | _] = [1,2,3]
head #=> 1
# For better readability we can do the following:
[head | _tail] = [:a, :b, :c]
head #=> :a
# `cond` lets us check for many conditions at the same time.
# Use `cond` instead of nesting many `if` expressions.
cond do
1 + 1 == 3 ->
"I will never be seen"
2 * 5 == 12 ->
"Me neither"
1 + 2 == 3 ->
"But I will"
end
# It is common to set the last condition equal to `true`, which will always match.
cond do
1 + 1 == 3 ->
"I will never be seen"
2 * 5 == 12 ->
"Me neither"
true ->
"But I will (this is essentially an else)"
end
# `try/catch` is used to catch values that are thrown, it also supports an
# `after` clause that is invoked whether or not a value is caught.
try do
throw(:hello)
catch
message -> "Got #{message}."
after
IO.puts("I'm the after clause.")
end
#=> I'm the after clause
# "Got :hello"
## ---------------------------
## -- Modules and Functions
## ---------------------------
# Anonymous functions (notice the dot)
square = fn(x) -> x * x end
square.(5) #=> 25
# They also accept many clauses and guards.
# Guards let you fine tune pattern matching,
# they are indicated by the `when` keyword:
f = fn
x, y when x > 0 -> x + y
x, y -> x * y
end
f.(1, 3) #=> 4
f.(-1, 3) #=> -3
# Elixir also provides many built-in functions.
# These are available in the current scope.
is_number(10) #=> true
is_list("hello") #=> false
elem({1,2,3}, 0) #=> 1
# You can group several functions into a module. Inside a module use `def`
# to define your functions.
defmodule Math do
def sum(a, b) do
a + b
end
def square(x) do
x * x
end
end
Math.sum(1, 2) #=> 3
Math.square(3) #=> 9
# To compile our simple Math module save it as `math.ex` and use `elixirc`
# in your terminal: elixirc math.ex
# Inside a module we can define functions with `def` and private functions with `defp`.
# A function defined with `def` is available to be invoked from other modules,
# a private function can only be invoked locally.
defmodule PrivateMath do
def sum(a, b) do
do_sum(a, b)
end
defp do_sum(a, b) do
a + b
end
end
PrivateMath.sum(1, 2) #=> 3
# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
# Function declarations also support guards and multiple clauses:
defmodule Geometry do
def area({:rectangle, w, h}) do
w * h
end
def area({:circle, r}) when is_number(r) do
3.14 * r * r
end
end
Geometry.area({:rectangle, 2, 3}) #=> 6
Geometry.area({:circle, 3}) #=> 28.25999999999999801048
# Geometry.area({:circle, "not_a_number"})
#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
# Due to immutability, recursion is a big part of elixir
defmodule Recursion do
def sum_list([head | tail], acc) do
sum_list(tail, acc + head)
end
def sum_list([], acc) do
acc
end
end
Recursion.sum_list([1,2,3], 0) #=> 6
# Elixir modules support attributes, there are built-in attributes and you
# may also add custom ones.
defmodule MyMod do
@moduledoc """
This is a built-in attribute on a example module.
"""
@my_data 100 # This is a custom attribute.
IO.inspect(@my_data) #=> 100
end
## ---------------------------
## -- Structs and Exceptions
## ---------------------------
# Structs are extensions on top of maps that bring default values,
# compile-time guarantees and polymorphism into Elixir.
defmodule Person do
defstruct name: nil, age: 0, height: 0
end
joe_info = %Person{ name: "Joe", age: 30, height: 180 }
#=> %Person{age: 30, height: 180, name: "Joe"}
# Access the value of name
joe_info.name #=> "Joe"
# Update the value of age
older_joe_info = %{ joe_info | age: 31 }
#=> %Person{age: 31, height: 180, name: "Joe"}
# The `try` block with the `rescue` keyword is used to handle exceptions
try do
raise "some error"
rescue
RuntimeError -> "rescued a runtime error"
_error -> "this will rescue any error"
end
#=> "rescued a runtime error"
# All exceptions have a message
try do
raise "some error"
rescue
x in [RuntimeError] ->
x.message
end
#=> "some error"
## ---------------------------
## -- Concurrency
## ---------------------------
# Elixir relies on the actor model for concurrency. All we need to write
# concurrent programs in elixir are three primitives: spawning processes,
# sending messages and receiving messages.
# To start a new process we use the `spawn` function, which takes a function
# as argument.
f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
spawn(f) #=> #PID<0.40.0>
# `spawn` returns a pid (process identifier), you can use this pid to send
# messages to the process. To do message passing we use the `send` operator.
# For all of this to be useful we need to be able to receive messages. This is
# achieved with the `receive` mechanism:
# The `receive do` block is used to listen for messages and process
# them when they are received. A `receive do` block will only
# process one received message. In order to process multiple
# messages, a function with a `receive do` block must recursively
# call itself to get into the `receive do` block again.
defmodule Geometry do
def area_loop do
receive do
{:rectangle, w, h} ->
IO.puts("Area = #{w * h}")
area_loop()
{:circle, r} ->
IO.puts("Area = #{3.14 * r * r}")
area_loop()
end
end
end
# Compile the module and create a process that evaluates `area_loop` in the shell
pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
# Alternatively
pid = spawn(Geometry, :area_loop, [])
# Send a message to `pid` that will match a pattern in the receive statement
send pid, {:rectangle, 2, 3}
#=> Area = 6
# {:rectangle,2,3}
send pid, {:circle, 2}
#=> Area = 12.56000000000000049738
# {:circle,2}
# The shell is also a process, you can use `self` to get the current pid
self() #=> #PID<0.27.0>
diff --git a/autotests/input/syntax/j/results/test.ijs.reference.html b/autotests/input/syntax/j/results/test.ijs.reference.html
index 2954cd67..c766d44b 100644
--- a/autotests/input/syntax/j/results/test.ijs.reference.html
+++ b/autotests/input/syntax/j/results/test.ijs.reference.html
@@ -1,75 +1,75 @@
test.ijs
-
+
Comment
NB. This is a single line comment, check regions overlapping priority: 1 2.3 +/ &. 'quoted text'
NB.(
NB. This is a foldable multi line comment
NB.)
String literal
''
''''
'This is quoted text'
'And this '' and this NB. and this' 'Yet another quoted text'
Numeric literal
12 34.56 _7.89 1e2 1.2e3 _. _ __ 123j_456 2b111.111 1r23 123456x 1.2e3j4.5e6 _j_ __j_ _.j_. _j3p4j_.
Parenthesis
( )
Adverb
~ / \ /. \. } b. f. M. t. t:
Conjuction
^: . .. .: : :. :: ;. !. !: " ` `: @ @. @: & &. &: &.: d. D. D: H. L: S: T.
Control
assert. break. case. catch. catchd. catcht. continue. do. else. elseif. end. fcase. for. for_abc. goto_abc. if. label_abc. return. select. throw. try. while. whilst.
Copula
a =: 123
(a) =: 123
(a;b;c) =: 123
'a b c' =: 123
'a b c' =. '123'
'`a b c' =. '123'
'a' =: 123
('a';'b';'c') =: 123
Explicit argument
x y m n u v x. y. m. n. u. v.
Noun
a. a:
Verb
= < <. <: > >. >: _: + +. +: * *. *: - -. -: % %. %: ^ ^. $ $. $: ~. ~: | |. |: , ,. ,: ; ;: # #. #: ! /: \: [ [: ] { {. {: {:: }. }: ". ": ? ?. A. C. e. E. i. i: I. j. L. o. p. p.. p: q: r. s: u: x: _9: _8: _7: _6: _5: _4: _3: _2: _1: 0: 1: 2: 3: 4: 5: 6: 7: 8: 9:
Combined
for_abc. i. 5 do. 55 return. end.
a=. b =: 123 +/ # i. 10
123 'qwerty'
a_b =: '123' [ c__d =. 4 : 0 NB. foldable definition begins
x +/ y
)
e__12 =: define NB. foldable definition begins
if. x do. NB. inner foldable region begins
y=. y + x NB. comment after code
x +/ y
else. NB. inner foldable region begins
y +/ y
end.
)
diff --git a/autotests/input/syntax/meson/results/meson.build.reference.html b/autotests/input/syntax/meson/results/meson.build.reference.html
index 759ba53b..b79afe26 100644
--- a/autotests/input/syntax/meson/results/meson.build.reference.html
+++ b/autotests/input/syntax/meson/results/meson.build.reference.html
@@ -1,35 +1,35 @@
meson.build
-
+
# Unit test for Meson syntax highlight. License: LGPL
project('projectname', 'cpp')
sourcefiles = ['a.cpp', 'b.cpp']
foreach sourcefile : sourcefiles
message('this is a source file: ' + sourcefile)
endforeach
x=1
if x+1 == 2 and x-1 == 0
message('I can work in this universe!')
endif
subprojectresult = subproject('mysubprojectdir')
mysharedlib = shared_library('libraryname', sourcefiles, linkwith: subprojectresult.staticlib)
executable('myprogram', ['test.cpp'], linkwith: mysharedlib)
diff --git a/autotests/input/syntax/rmarkdown/results/example.rmd.reference.html b/autotests/input/syntax/rmarkdown/results/example.rmd.reference.html
index ced6208c..e1b8e564 100644
--- a/autotests/input/syntax/rmarkdown/results/example.rmd.reference.html
+++ b/autotests/input/syntax/rmarkdown/results/example.rmd.reference.html
@@ -1,53 +1,53 @@
example.rmd
-
+
---
title: "test"
author: "me"
date: "07.10.2014"
output: html_document
---
This is a simple test document. It shows syntax highlighting switches between YAML (above), R blocks
```{r, echo=FALSE}
for (i in 1:10) {
if(i>=10) print(i)
}
# two blank lines below
sessionInfo()
```
LaTeX equations,
$$
h_{i}(t \mid q,C) = h_{0}(t) e^{\beta_{1}quality_{i} + \beta_{2}C_{iq}}
$$
and Markdown. A [link](http://example.com) in Markdown.
Inline `r y <- 5 + x - sin(3)` R code.
Inline `y <- 5 + x - sin(3)` code.
Heading
=======
Sub-heading
-----------
A list of editors:
* kate
* vim
* emacs
*italic*, **bold**, `monospace`
diff --git a/autotests/input/syntax/sql-oracle/results/test_syntax.sql.reference.html b/autotests/input/syntax/sql-oracle/results/test_syntax.sql.reference.html
index 155a976a..d75a924c 100644
--- a/autotests/input/syntax/sql-oracle/results/test_syntax.sql.reference.html
+++ b/autotests/input/syntax/sql-oracle/results/test_syntax.sql.reference.html
@@ -1,54 +1,54 @@
test_syntax.sql
-
+
-- kate: hl SQL (Oracle)
-- test case shipped with highlighting in bugzilla, LGPL
begin
q'{adfasdf'sadfasdf j}'{' hkjhkhkjhkjh khlkhklj'fghdfghdfgh'hkjh'jkhkh'a'
Q'(asldflahsl;'dkjfhklsdfh)'
q'[asdasd;'asdasd'a]sd'asd'asasd]';11111111[1']; asdasdasdasd'errrrrrrrrrrrrrr-p
q'agdfgsdfgfhfghjfgh'f'f'sdfg'sdfg'dfg#a' dafdfadasfasdf;
Q'#gdfgsdfgsdfgsdfgsdfg#' afgasasdfasdfasfasdfasdfasdfasdfsdf
if sldfjsdj then
case
when 1=1 then
aslfjsldkfj;
when 2=2 then
asdfg;
else
null;
end case;
if sdfjh then
for i in 1 .. 2
LOOP
dbms_output.put_line(q';ololo;');
END Loop;
while true
loop
dbms_output.put_line('1111');
end loop;
end if;
ksjfklasjd;
fklj;
elsif
sdklfjsdklfj;
else
sdfdfsdf;
end if;
end;
diff --git a/autotests/input/syntax/verilog/results/or1200_dc_fsm.v.reference.html b/autotests/input/syntax/verilog/results/or1200_dc_fsm.v.reference.html
index 5c15f923..25f2053e 100644
--- a/autotests/input/syntax/verilog/results/or1200_dc_fsm.v.reference.html
+++ b/autotests/input/syntax/verilog/results/or1200_dc_fsm.v.reference.html
@@ -1,577 +1,577 @@
or1200_dc_fsm.v
-
+
//////////////////////////////////////////////////////////////////////
//// ////
//// OR1200's DC FSM ////
//// ////
//// This file is part of the OpenRISC 1200 project ////
//// http://opencores.org/project,or1k ////
//// ////
//// Description ////
//// Data cache state machine ////
//// ////
//// To Do: ////
//// - Test error during line read or write ////
//// ////
//// Author(s): ////
//// - Damjan Lampret, lampret@opencores.org ////
//// - Julius Baxter, julius@opencores.org ////
//// ////
//////////////////////////////////////////////////////////////////////
//// ////
//// Copyright (C) 2000, 2010 Authors and OPENCORES.ORG ////
//// ////
//// This source file may be used and distributed without ////
//// restriction provided that this copyright statement is not ////
//// removed from the file and that any derivative work contains ////
//// the original copyright notice and the associated disclaimer. ////
//// ////
//// This source file is free software; you can redistribute it ////
//// and/or modify it under the terms of the GNU Lesser General ////
//// Public License as published by the Free Software Foundation; ////
//// either version 2.1 of the License, or (at your option) any ////
//// later version. ////
//// ////
//// This source 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 Lesser General Public License for more ////
//// details. ////
//// ////
//// You should have received a copy of the GNU Lesser General ////
//// Public License along with this source; if not, download it ////
//// from http://www.opencores.org/lgpl.shtml ////
//// ////
//////////////////////////////////////////////////////////////////////
//
// $Log: or1200_dc_fsm.v,v $
// Revision 2.0 2010/06/30 11:00:00 ORSoC
// Minor update:
// Bugs fixed.
//
// synopsys translate_off
`include "timescale.v"
// synopsys translate_on
`include "or1200_defines.v"
`define OR1200_DCFSM_IDLE 3'd0
`define OR1200_DCFSM_CLOADSTORE 3'd1
`define OR1200_DCFSM_LOOP2 3'd2
`define OR1200_DCFSM_LOOP3 3'd3
`define OR1200_DCFSM_LOOP4 3'd4
`define OR1200_DCFSM_FLUSH5 3'd5
`define OR1200_DCFSM_INV6 3'd6
`define OR1200_DCFSM_WAITSPRCS7 3'd7
//
// Data cache FSM for cache line of 16 bytes (4x singleword)
//
module or1200_dc_fsm
(
// Clock and reset
clk, rst,
// Internal i/f to top level DC
dc_en, dcqmem_cycstb_i, dcqmem_ci_i, dcqmem_we_i, dcqmem_sel_i,
tagcomp_miss, biudata_valid, biudata_error, lsu_addr,
dcram_we, biu_read, biu_write, biu_do_sel, dcram_di_sel, first_hit_ack,
first_miss_ack, first_miss_err, burst, tag_we, tag_valid, dc_addr,
dc_no_writethrough, tag_dirty, dirty, tag, tag_v, dc_block_flush,
dc_block_writeback, spr_dat_i, mtspr_dc_done, spr_cswe
);
//
// I/O
//
input clk;
input rst;
input dc_en;
input dcqmem_cycstb_i;
input dcqmem_ci_i;
input dcqmem_we_i;
input [3:0] dcqmem_sel_i;
input tagcomp_miss;
input biudata_valid;
input biudata_error;
input [31:0] lsu_addr;
output [3:0] dcram_we;
output biu_read;
output biu_write;
output dcram_di_sel;
output biu_do_sel;
output first_hit_ack;
output first_miss_ack;
output first_miss_err;
output burst;
output tag_we;
output tag_valid;
output [31:0] dc_addr;
input dc_no_writethrough;
output tag_dirty;
input dirty;
input [`OR1200_DCTAG_W-2:0] tag;
input tag_v;
input dc_block_flush;
input dc_block_writeback;
input [31:0] spr_dat_i;
output mtspr_dc_done;
input spr_cswe;
//
// Internal wires and regs
//
reg [31:0] addr_r;
reg [2:0] state;
reg [`OR1200_DCLS-1:0] cnt;
reg hitmiss_eval;
reg store;
reg load;
reg cache_inhibit;
reg cache_miss;
reg cache_dirty_needs_writeback;
reg did_early_load_ack;
reg cache_spr_block_flush;
reg cache_spr_block_writeback;
reg cache_wb;
wire load_hit_ack;
wire load_miss_ack;
wire load_inhibit_ack;
wire store_hit_ack;
wire store_hit_writethrough_ack;
wire store_miss_writethrough_ack;
wire store_inhibit_ack;
wire store_miss_ack;
wire dcram_we_after_line_load;
wire dcram_we_during_line_load;
wire tagram_we_end_of_loadstore_loop;
wire tagram_dirty_bit_set;
wire writethrough;
wire cache_inhibit_with_eval;
wire [(`OR1200_DCLS-1)-2:0] next_addr_word;
//
// Cache inhibit
//
// Indicates whether cache is inhibited, during hitmiss_eval and after
assign cache_inhibit_with_eval = (hitmiss_eval & dcqmem_ci_i) |
(!hitmiss_eval & cache_inhibit);
//
// Generate of DCRAM write enables
//
// WE when non-writethrough, and had to wait for a line to load.
assign dcram_we_after_line_load = (state == `OR1200_DCFSM_LOOP3) &
dcqmem_we_i & !cache_dirty_needs_writeback &
!did_early_load_ack;
// WE when receiving the data cache line
assign dcram_we_during_line_load = (state == `OR1200_DCFSM_LOOP2) & load &
biudata_valid;
assign dcram_we =(// Write when hit - make sure it is only when hit - could
// maybe be doing write through and don't want to corrupt
// cache lines corresponding to the writethrough addr_r.
({4{store_hit_ack | store_hit_writethrough_ack}} |
// Write after load of line
{4{dcram_we_after_line_load}}) &
dcqmem_sel_i ) |
// Write during load
{4{dcram_we_during_line_load}};
//
// Tag RAM signals
//
// WE to tag RAM when we finish loading a line.
assign tagram_we_end_of_loadstore_loop = ((state==`OR1200_DCFSM_LOOP2) &
biudata_valid & !(|cnt));
`ifndef OR1200_DC_WRITETHROUGH
// No writethrough, so mark a line dirty whenever we write to it
assign tagram_dirty_bit_set = store_hit_ack | store_miss_ack;
// Generate done signal for MTSPR instructions that may block execution
assign mtspr_dc_done = // Either DC disabled or we're not selected, or
!dc_en | !spr_cswe |
// Requested address not valid or writeback and !dirty
((state==`OR1200_DCFSM_FLUSH5) &
(!tag_v | (cache_spr_block_writeback & !dirty))) |
// Writeback or flush is finished
((state==`OR1200_DCFSM_LOOP3) &
(cache_spr_block_flush | cache_spr_block_writeback))|
// Invalidate of clean line finished
((state==`OR1200_DCFSM_INV6) & cache_spr_block_flush);
`else
`ifdef OR1200_DC_NOSTACKWRITETHROUGH
// For dirty bit setting when having writethrough but not for stack
assign tagram_dirty_bit_set = store_hit_ack | store_miss_ack;
`else
// Lines will never be dirty if always writethrough
assign tagram_dirty_bit_set = 0;
`endif
assign mtspr_dc_done = 1'b1;
`endif
assign tag_dirty = tagram_dirty_bit_set;
// WE to tag RAM
assign tag_we = tagram_we_end_of_loadstore_loop |
tagram_dirty_bit_set | (state == `OR1200_DCFSM_INV6);
// Valid bit
// Set valid when end of line load, or marking dirty (is still valid)
assign tag_valid = ( tagram_we_end_of_loadstore_loop &
(load | (store & cache_spr_block_writeback)) ) |
tagram_dirty_bit_set;
//
// BIU read and write
//
assign biu_read = // Bus read request when:
// 1) Have a miss and not dirty or a load with inhibit
((state == `OR1200_DCFSM_CLOADSTORE) &
(((hitmiss_eval & tagcomp_miss & !dirty &
!(store & writethrough)) |
(load & cache_inhibit_with_eval)) & dcqmem_cycstb_i)) |
// 2) In the loop and loading
((state == `OR1200_DCFSM_LOOP2) & load);
assign biu_write = // Bus write request when:
// 1) Have a miss and dirty or store with inhibit
((state == `OR1200_DCFSM_CLOADSTORE) &
(((hitmiss_eval & tagcomp_miss & dirty) |
(store & writethrough)) |
(store & cache_inhibit_with_eval)) & dcqmem_cycstb_i) |
// 2) In the loop and storing
((state == `OR1200_DCFSM_LOOP2) & store);
//
// Select for data to actual cache RAM (from LSU or BIU)
//
// Data to DCRAM - from external bus when loading (from IU when store)
assign dcram_di_sel = load;
// Data to external bus - always from IU except in case of bursting back
// the line to memory. (1 selects DCRAM)
assign biu_do_sel = (state == `OR1200_DCFSM_LOOP2) & store;
// 3-bit wire for calculating next word of burst write, depending on
// line size of data cache.
assign next_addr_word = addr_r[`OR1200_DCLS-1:2] + 1;
// Address to cache RAM (tag address also derived from this)
assign dc_addr =
// First check if we've got a block flush or WB op
((dc_block_flush & !cache_spr_block_flush) |
(dc_block_writeback & !cache_spr_block_writeback)) ?
spr_dat_i :
(state==`OR1200_DCFSM_FLUSH5) ? addr_r:
// If no SPR action, then always put out address from LSU
(state==`OR1200_DCFSM_IDLE | hitmiss_eval) ? lsu_addr :
// Next, if in writeback loop, when ACKed must immediately
// output next word address (the RAM address takes a cycle
// to increment, but it's needed immediately for burst)
// otherwise, output our registered address.
(state==`OR1200_DCFSM_LOOP2 & biudata_valid & store ) ?
{addr_r[31:`OR1200_DCLS], next_addr_word, 2'b00} : addr_r;
`ifdef OR1200_DC_WRITETHROUGH
`ifdef OR1200_DC_NOSTACKWRITETHROUGH
assign writethrough = !dc_no_writethrough;
`else
assign writethrough = 1;
`endif
`else
assign writethrough = 0;
`endif
//
// ACK generation for LSU
//
// ACK for when it's a cache hit
assign first_hit_ack = load_hit_ack | store_hit_ack |
store_hit_writethrough_ack |
store_miss_writethrough_ack |
store_inhibit_ack | store_miss_ack ;
// ACK for when it's a cache miss - load only, is used in MUX for data back
// LSU straight off external data bus. In
// this was is also used for cache inhibit
// loads.
// first_hit_ack takes precedence over first_miss_ack
assign first_miss_ack = ~first_hit_ack & (load_miss_ack | load_inhibit_ack);
// ACK cache hit on load
assign load_hit_ack = (state == `OR1200_DCFSM_CLOADSTORE) &
hitmiss_eval & !tagcomp_miss & !dcqmem_ci_i & load;
// ACK cache hit on store, no writethrough
assign store_hit_ack = (state == `OR1200_DCFSM_CLOADSTORE) &
hitmiss_eval & !tagcomp_miss & !dcqmem_ci_i &
store & !writethrough;
// ACK cache hit on store with writethrough
assign store_hit_writethrough_ack = (state == `OR1200_DCFSM_CLOADSTORE) &
!cache_miss & !cache_inhibit &
store & writethrough & biudata_valid;
// ACK cache miss on store with writethrough
assign store_miss_writethrough_ack = (state == `OR1200_DCFSM_CLOADSTORE) &
cache_miss & !cache_inhibit &
store & writethrough & biudata_valid;
// ACK store when cacheinhibit
assign store_inhibit_ack = (state == `OR1200_DCFSM_CLOADSTORE) &
store & cache_inhibit & biudata_valid;
// Get the _early_ ack on first ACK back from wishbone during load only
// Condition is that we're in the loop - that it's the first ack we get (can
// tell from value of cnt), and we're loading a line to read from it (not
// loading to write to it, in the case of a write without writethrough.)
assign load_miss_ack = ((state== `OR1200_DCFSM_LOOP2) & load &
(cnt==((1 << `OR1200_DCLS) - 4)) & biudata_valid &
!(dcqmem_we_i & !writethrough));
assign load_inhibit_ack = (state == `OR1200_DCFSM_CLOADSTORE) &
load & cache_inhibit & biudata_valid;
// This will be case of write through disabled, and had to load a line.
assign store_miss_ack = dcram_we_after_line_load;
assign first_miss_err = biudata_error & dcqmem_cycstb_i;
// Signal burst when in the load/store loop. We will always try to burst.
assign burst = (state == `OR1200_DCFSM_LOOP2);
//
// Main DC FSM
//
always @(posedge clk or `OR1200_RST_EVENT rst) begin
if (rst == `OR1200_RST_VALUE) begin
state <= `OR1200_DCFSM_IDLE;
addr_r <= 32'd0;
hitmiss_eval <= 1'b0;
store <= 1'b0;
load <= 1'b0;
cnt <= `OR1200_DCLS'd0;
cache_miss <= 1'b0;
cache_dirty_needs_writeback <= 1'b0;
cache_inhibit <= 1'b0;
did_early_load_ack <= 1'b0;
cache_spr_block_flush <= 1'b0;
cache_spr_block_writeback <= 1'b0;
end
else
case (state) // synopsys parallel_case
`OR1200_DCFSM_IDLE : begin
if (dc_en & (dc_block_flush | dc_block_writeback))
begin
cache_spr_block_flush <= dc_block_flush;
cache_spr_block_writeback <= dc_block_writeback;
hitmiss_eval <= 1'b1;
state <= `OR1200_DCFSM_FLUSH5;
addr_r <= spr_dat_i;
end
else if (dc_en & dcqmem_cycstb_i)
begin
state <= `OR1200_DCFSM_CLOADSTORE;
hitmiss_eval <= 1'b1;
store <= dcqmem_we_i;
load <= !dcqmem_we_i;
end
end // case: `OR1200_DCFSM_IDLE
`OR1200_DCFSM_CLOADSTORE: begin
hitmiss_eval <= 1'b0;
if (hitmiss_eval) begin
cache_inhibit <= dcqmem_ci_i; // Check for cache inhibit here
cache_miss <= tagcomp_miss;
cache_dirty_needs_writeback <= dirty;
addr_r <= lsu_addr;
end
// Evaluate any cache line load/stores in first cycle:
//
if (hitmiss_eval & tagcomp_miss & !(store & writethrough) &
!dcqmem_ci_i)
begin
// Miss - first either:
// 1) write back dirty line
if (dirty) begin
// Address for writeback
addr_r <= {tag, lsu_addr[`OR1200_DCINDXH:2],2'd0};
load <= 1'b0;
store <= 1'b1;
`ifdef OR1200_VERBOSE
$display("%t: dcache miss and dirty", $time);
`endif
end
// 2) load requested line
else begin
addr_r <= lsu_addr;
load <= 1'b1;
store <= 1'b0;
end // else: !if(dirty)
state <= `OR1200_DCFSM_LOOP2;
// Set the counter for the burst accesses
cnt <= ((1 << `OR1200_DCLS) - 4);
end
else if (// Strobe goes low
!dcqmem_cycstb_i |
// Cycle finishes
(!hitmiss_eval & (biudata_valid | biudata_error)) |
// Cache hit in first cycle....
(hitmiss_eval & !tagcomp_miss & !dcqmem_ci_i &
// .. and you're not doing a writethrough store..
!(store & writethrough))) begin
state <= `OR1200_DCFSM_IDLE;
load <= 1'b0;
store <= 1'b0;
cache_inhibit <= 1'b0;
cache_dirty_needs_writeback <= 1'b0;
end
end // case: `OR1200_DCFSM_CLOADSTORE
`OR1200_DCFSM_LOOP2 : begin // loop/abort
if (!dc_en| biudata_error) begin
state <= `OR1200_DCFSM_IDLE;
load <= 1'b0;
store <= 1'b0;
cnt <= `OR1200_DCLS'd0;
end
if (biudata_valid & (|cnt)) begin
cnt <= cnt - 4;
addr_r[`OR1200_DCLS-1:2] <= addr_r[`OR1200_DCLS-1:2] + 1;
end
else if (biudata_valid & !(|cnt)) begin
state <= `OR1200_DCFSM_LOOP3;
addr_r <= lsu_addr;
load <= 1'b0;
store <= 1'b0;
end
// Track if we did an early ack during a load
if (load_miss_ack)
did_early_load_ack <= 1'b1;
end // case: `OR1200_DCFSM_LOOP2
`OR1200_DCFSM_LOOP3: begin // figure out next step
if (cache_dirty_needs_writeback) begin
// Just did store of the dirty line so now load new one
load <= 1'b1;
// Set the counter for the burst accesses
cnt <= ((1 << `OR1200_DCLS) - 4);
// Address of line to be loaded
addr_r <= lsu_addr;
cache_dirty_needs_writeback <= 1'b0;
state <= `OR1200_DCFSM_LOOP2;
end // if (cache_dirty_needs_writeback)
else if (cache_spr_block_flush | cache_spr_block_writeback) begin
// Just wrote back the line to memory, we're finished.
cache_spr_block_flush <= 1'b0;
cache_spr_block_writeback <= 1'b0;
state <= `OR1200_DCFSM_WAITSPRCS7;
end
else begin
// Just loaded a new line, finish up
did_early_load_ack <= 1'b0;
state <= `OR1200_DCFSM_LOOP4;
end
end // case: `OR1200_DCFSM_LOOP3
`OR1200_DCFSM_LOOP4: begin
state <= `OR1200_DCFSM_IDLE;
end
`OR1200_DCFSM_FLUSH5: begin
hitmiss_eval <= 1'b0;
if (hitmiss_eval & !tag_v)
begin
// Not even cached, just ignore
cache_spr_block_flush <= 1'b0;
cache_spr_block_writeback <= 1'b0;
state <= `OR1200_DCFSM_WAITSPRCS7;
end
else if (hitmiss_eval & tag_v)
begin
// Tag is valid - what do we do?
if ((cache_spr_block_flush | cache_spr_block_writeback) &
dirty) begin
// Need to writeback
// Address for writeback (spr_dat_i has already changed so
// use line number from addr_r)
addr_r <= {tag, addr_r[`OR1200_DCINDXH:2],2'd0};
load <= 1'b0;
store <= 1'b1;
`ifdef OR1200_VERBOSE
$display("%t: block flush: dirty block", $time);
`endif
state <= `OR1200_DCFSM_LOOP2;
// Set the counter for the burst accesses
cnt <= ((1 << `OR1200_DCLS) - 4);
end
else if (cache_spr_block_flush & !dirty)
begin
// Line not dirty, just need to invalidate
state <= `OR1200_DCFSM_INV6;
end // else: !if(dirty)
else if (cache_spr_block_writeback & !dirty)
begin
// Nothing to do - line is valid but not dirty
cache_spr_block_writeback <= 1'b0;
state <= `OR1200_DCFSM_WAITSPRCS7;
end
end // if (hitmiss_eval & tag_v)
end
`OR1200_DCFSM_INV6: begin
cache_spr_block_flush <= 1'b0;
// Wait until SPR CS goes low before going back to idle
if (!spr_cswe)
state <= `OR1200_DCFSM_IDLE;
end
`OR1200_DCFSM_WAITSPRCS7: begin
// Wait until SPR CS goes low before going back to idle
if (!spr_cswe)
state <= `OR1200_DCFSM_IDLE;
end
endcase // case (state)
end // always @ (posedge clk or `OR1200_RST_EVENT rst)
endmodule
diff --git a/autotests/input/syntax/verilog/results/or1200_du.v.reference.html b/autotests/input/syntax/verilog/results/or1200_du.v.reference.html
index e319fffb..7fb1cf57 100644
--- a/autotests/input/syntax/verilog/results/or1200_du.v.reference.html
+++ b/autotests/input/syntax/verilog/results/or1200_du.v.reference.html
@@ -1,1817 +1,1817 @@
or1200_du.v
-
+
//////////////////////////////////////////////////////////////////////
//// ////
//// OR1200's Debug Unit ////
//// ////
//// This file is part of the OpenRISC 1200 project ////
//// http://www.opencores.org/project,or1k ////
//// ////
//// Description ////
//// Basic OR1200 debug unit. ////
//// ////
//// To Do: ////
//// - make it smaller and faster ////
//// ////
//// Author(s): ////
//// - Damjan Lampret, lampret@opencores.org ////
//// ////
//////////////////////////////////////////////////////////////////////
//// ////
//// Copyright (C) 2000 Authors and OPENCORES.ORG ////
//// ////
//// This source file may be used and distributed without ////
//// restriction provided that this copyright statement is not ////
//// removed from the file and that any derivative work contains ////
//// the original copyright notice and the associated disclaimer. ////
//// ////
//// This source file is free software; you can redistribute it ////
//// and/or modify it under the terms of the GNU Lesser General ////
//// Public License as published by the Free Software Foundation; ////
//// either version 2.1 of the License, or (at your option) any ////
//// later version. ////
//// ////
//// This source 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 Lesser General Public License for more ////
//// details. ////
//// ////
//// You should have received a copy of the GNU Lesser General ////
//// Public License along with this source; if not, download it ////
//// from http://www.opencores.org/lgpl.shtml ////
//// ////
//////////////////////////////////////////////////////////////////////
//
//
// $Log: or1200_du.v,v $
// Revision 2.0 2010/06/30 11:00:00 ORSoC
// Minor update:
// Bugs fixed.
// synopsys translate_off
`include "timescale.v"
// synopsys translate_on
`include "or1200_defines.v"
//
// Debug unit
//
module or1200_du(
// RISC Internal Interface
clk, rst,
dcpu_cycstb_i, dcpu_we_i, dcpu_adr_i, dcpu_dat_lsu,
dcpu_dat_dc, icpu_cycstb_i,
ex_freeze, branch_op, ex_insn, id_pc,
spr_dat_npc, rf_dataw,
du_dsr, du_dmr1, du_stall, du_addr, du_dat_i, du_dat_o,
du_read, du_write, du_except_stop, du_hwbkpt, du_flush_pipe,
spr_cs, spr_write, spr_addr, spr_dat_i, spr_dat_o,
// External Debug Interface
dbg_stall_i, dbg_ewt_i, dbg_lss_o, dbg_is_o, dbg_wp_o, dbg_bp_o,
dbg_stb_i, dbg_we_i, dbg_adr_i, dbg_dat_i, dbg_dat_o, dbg_ack_o
);
parameter dw = `OR1200_OPERAND_WIDTH;
parameter aw = `OR1200_OPERAND_WIDTH;
//
// I/O
//
//
// RISC Internal Interface
//
input clk; // Clock
input rst; // Reset
input dcpu_cycstb_i; // LSU status
input dcpu_we_i; // LSU status
input [31:0] dcpu_adr_i; // LSU addr
input [31:0] dcpu_dat_lsu; // LSU store data
input [31:0] dcpu_dat_dc; // LSU load data
input [`OR1200_FETCHOP_WIDTH-1:0] icpu_cycstb_i; // IFETCH unit status
input ex_freeze; // EX stage freeze
input [`OR1200_BRANCHOP_WIDTH-1:0] branch_op; // Branch op
input [dw-1:0] ex_insn; // EX insn
input [31:0] id_pc; // insn fetch EA
input [31:0] spr_dat_npc; // Next PC (for trace)
input [31:0] rf_dataw; // ALU result (for trace)
output [`OR1200_DU_DSR_WIDTH-1:0] du_dsr; // DSR
output [24: 0] du_dmr1;
output du_stall; // Debug Unit Stall
output [aw-1:0] du_addr; // Debug Unit Address
input [dw-1:0] du_dat_i; // Debug Unit Data In
output [dw-1:0] du_dat_o; // Debug Unit Data Out
output du_read; // Debug Unit Read Enable
output du_write; // Debug Unit Write Enable
input [13:0] du_except_stop; // Exception masked by DSR
output du_hwbkpt; // Cause trap exception (HW Breakpoints)
output du_flush_pipe; // Cause pipeline flush and pc<-npc
input spr_cs; // SPR Chip Select
input spr_write; // SPR Read/Write
input [aw-1:0] spr_addr; // SPR Address
input [dw-1:0] spr_dat_i; // SPR Data Input
output [dw-1:0] spr_dat_o; // SPR Data Output
//
// External Debug Interface
//
input dbg_stall_i; // External Stall Input
input dbg_ewt_i; // External Watchpoint Trigger Input
output [3:0] dbg_lss_o; // External Load/Store Unit Status
output [1:0] dbg_is_o; // External Insn Fetch Status
output [10:0] dbg_wp_o; // Watchpoints Outputs
output dbg_bp_o; // Breakpoint Output
input dbg_stb_i; // External Address/Data Strobe
input dbg_we_i; // External Write Enable
input [aw-1:0] dbg_adr_i; // External Address Input
input [dw-1:0] dbg_dat_i; // External Data Input
output [dw-1:0] dbg_dat_o; // External Data Output
output dbg_ack_o; // External Data Acknowledge (not WB compatible)
reg [dw-1:0] dbg_dat_o; // External Data Output
reg dbg_ack_o; // External Data Acknowledge (not WB compatible)
//
// Some connections go directly from the CPU through DU to Debug I/F
//
`ifdef OR1200_DU_STATUS_UNIMPLEMENTED
assign dbg_lss_o = 4'b0000;
reg [1:0] dbg_is_o;
//
// Show insn activity (temp, must be removed)
//
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dbg_is_o <= 2'b00;
else if (!ex_freeze & ~((ex_insn[31:26] == `OR1200_OR32_NOP) & ex_insn[16]))
dbg_is_o <= ~dbg_is_o;
`ifdef UNUSED
assign dbg_is_o = 2'b00;
`endif
`else
assign dbg_lss_o = dcpu_cycstb_i ? {dcpu_we_i, 3'b000} : 4'b0000;
assign dbg_is_o = {1'b0, icpu_cycstb_i};
`endif
assign dbg_wp_o = 11'b000_0000_0000;
//
// Some connections go directly from Debug I/F through DU to the CPU
//
assign du_stall = dbg_stall_i;
assign du_addr = dbg_adr_i;
assign du_dat_o = dbg_dat_i;
assign du_read = dbg_stb_i && !dbg_we_i;
assign du_write = dbg_stb_i && dbg_we_i;
//
// After a sw breakpoint, the replaced instruction need to be executed.
// We flush the entire pipeline and set the pc to the current address
// to execute the restored address.
//
reg du_flush_pipe_r;
reg dbg_stall_i_r;
assign du_flush_pipe = du_flush_pipe_r;
//
// Register du_flush_pipe
//
always @(posedge clk or `OR1200_RST_EVENT rst) begin
if (rst == `OR1200_RST_VALUE) begin
du_flush_pipe_r <= 1'b0;
end
else begin
du_flush_pipe_r <= (dbg_stall_i_r && !dbg_stall_i && |du_except_stop);
end
end
//
// Detect dbg_stall falling edge
//
always @(posedge clk or `OR1200_RST_EVENT rst) begin
if (rst == `OR1200_RST_VALUE) begin
dbg_stall_i_r <= 1'b0;
end
else begin
dbg_stall_i_r <= dbg_stall_i;
end
end
reg dbg_ack;
//
// Generate acknowledge -- just delay stb signal
//
always @(posedge clk or `OR1200_RST_EVENT rst) begin
if (rst == `OR1200_RST_VALUE) begin
dbg_ack <= 1'b0;
dbg_ack_o <= 1'b0;
end
else begin
dbg_ack <= dbg_stb_i; // valid when du_dat_i
dbg_ack_o <= dbg_ack & dbg_stb_i; // valid when dbg_dat_o
end
end
//
// Register data output
//
always @(posedge clk)
dbg_dat_o <= du_dat_i;
`ifdef OR1200_DU_IMPLEMENTED
//
// Debug Mode Register 1
//
`ifdef OR1200_DU_DMR1
reg [24:0] dmr1; // DMR1 implemented
`else
wire [24:0] dmr1; // DMR1 not implemented
`endif
assign du_dmr1 = dmr1;
//
// Debug Mode Register 2
//
`ifdef OR1200_DU_DMR2
reg [23:0] dmr2; // DMR2 implemented
`else
wire [23:0] dmr2; // DMR2 not implemented
`endif
//
// Debug Stop Register
//
`ifdef OR1200_DU_DSR
reg [`OR1200_DU_DSR_WIDTH-1:0] dsr; // DSR implemented
`else
wire [`OR1200_DU_DSR_WIDTH-1:0] dsr; // DSR not implemented
`endif
//
// Debug Reason Register
//
`ifdef OR1200_DU_DRR
reg [13:0] drr; // DRR implemented
`else
wire [13:0] drr; // DRR not implemented
`endif
//
// Debug Value Register N
//
`ifdef OR1200_DU_DVR0
reg [31:0] dvr0;
`else
wire [31:0] dvr0;
`endif
//
// Debug Value Register N
//
`ifdef OR1200_DU_DVR1
reg [31:0] dvr1;
`else
wire [31:0] dvr1;
`endif
//
// Debug Value Register N
//
`ifdef OR1200_DU_DVR2
reg [31:0] dvr2;
`else
wire [31:0] dvr2;
`endif
//
// Debug Value Register N
//
`ifdef OR1200_DU_DVR3
reg [31:0] dvr3;
`else
wire [31:0] dvr3;
`endif
//
// Debug Value Register N
//
`ifdef OR1200_DU_DVR4
reg [31:0] dvr4;
`else
wire [31:0] dvr4;
`endif
//
// Debug Value Register N
//
`ifdef OR1200_DU_DVR5
reg [31:0] dvr5;
`else
wire [31:0] dvr5;
`endif
//
// Debug Value Register N
//
`ifdef OR1200_DU_DVR6
reg [31:0] dvr6;
`else
wire [31:0] dvr6;
`endif
//
// Debug Value Register N
//
`ifdef OR1200_DU_DVR7
reg [31:0] dvr7;
`else
wire [31:0] dvr7;
`endif
//
// Debug Control Register N
//
`ifdef OR1200_DU_DCR0
reg [7:0] dcr0;
`else
wire [7:0] dcr0;
`endif
//
// Debug Control Register N
//
`ifdef OR1200_DU_DCR1
reg [7:0] dcr1;
`else
wire [7:0] dcr1;
`endif
//
// Debug Control Register N
//
`ifdef OR1200_DU_DCR2
reg [7:0] dcr2;
`else
wire [7:0] dcr2;
`endif
//
// Debug Control Register N
//
`ifdef OR1200_DU_DCR3
reg [7:0] dcr3;
`else
wire [7:0] dcr3;
`endif
//
// Debug Control Register N
//
`ifdef OR1200_DU_DCR4
reg [7:0] dcr4;
`else
wire [7:0] dcr4;
`endif
//
// Debug Control Register N
//
`ifdef OR1200_DU_DCR5
reg [7:0] dcr5;
`else
wire [7:0] dcr5;
`endif
//
// Debug Control Register N
//
`ifdef OR1200_DU_DCR6
reg [7:0] dcr6;
`else
wire [7:0] dcr6;
`endif
//
// Debug Control Register N
//
`ifdef OR1200_DU_DCR7
reg [7:0] dcr7;
`else
wire [7:0] dcr7;
`endif
//
// Debug Watchpoint Counter Register 0
//
`ifdef OR1200_DU_DWCR0
reg [31:0] dwcr0;
`else
wire [31:0] dwcr0;
`endif
//
// Debug Watchpoint Counter Register 1
//
`ifdef OR1200_DU_DWCR1
reg [31:0] dwcr1;
`else
wire [31:0] dwcr1;
`endif
//
// Internal wires
//
wire dmr1_sel; // DMR1 select
wire dmr2_sel; // DMR2 select
wire dsr_sel; // DSR select
wire drr_sel; // DRR select
wire dvr0_sel,
dvr1_sel,
dvr2_sel,
dvr3_sel,
dvr4_sel,
dvr5_sel,
dvr6_sel,
dvr7_sel; // DVR selects
wire dcr0_sel,
dcr1_sel,
dcr2_sel,
dcr3_sel,
dcr4_sel,
dcr5_sel,
dcr6_sel,
dcr7_sel; // DCR selects
wire dwcr0_sel,
dwcr1_sel; // DWCR selects
reg dbg_bp_r;
reg ex_freeze_q;
`ifdef OR1200_DU_HWBKPTS
reg [31:0] match_cond0_ct;
reg [31:0] match_cond1_ct;
reg [31:0] match_cond2_ct;
reg [31:0] match_cond3_ct;
reg [31:0] match_cond4_ct;
reg [31:0] match_cond5_ct;
reg [31:0] match_cond6_ct;
reg [31:0] match_cond7_ct;
reg match_cond0_stb;
reg match_cond1_stb;
reg match_cond2_stb;
reg match_cond3_stb;
reg match_cond4_stb;
reg match_cond5_stb;
reg match_cond6_stb;
reg match_cond7_stb;
reg match0;
reg match1;
reg match2;
reg match3;
reg match4;
reg match5;
reg match6;
reg match7;
reg wpcntr0_match;
reg wpcntr1_match;
reg incr_wpcntr0;
reg incr_wpcntr1;
reg [10:0] wp;
`endif
wire du_hwbkpt;
reg du_hwbkpt_hold;
`ifdef OR1200_DU_READREGS
reg [31:0] spr_dat_o;
`endif
reg [13:0] except_stop; // Exceptions that stop because of DSR
`ifdef OR1200_DU_TB_IMPLEMENTED
wire tb_enw;
reg [7:0] tb_wadr;
reg [31:0] tb_timstmp;
`endif
wire [31:0] tbia_dat_o;
wire [31:0] tbim_dat_o;
wire [31:0] tbar_dat_o;
wire [31:0] tbts_dat_o;
//
// DU registers address decoder
//
`ifdef OR1200_DU_DMR1
assign dmr1_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DMR1));
`endif
`ifdef OR1200_DU_DMR2
assign dmr2_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DMR2));
`endif
`ifdef OR1200_DU_DSR
assign dsr_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DSR));
`endif
`ifdef OR1200_DU_DRR
assign drr_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DRR));
`endif
`ifdef OR1200_DU_DVR0
assign dvr0_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DVR0));
`endif
`ifdef OR1200_DU_DVR1
assign dvr1_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DVR1));
`endif
`ifdef OR1200_DU_DVR2
assign dvr2_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DVR2));
`endif
`ifdef OR1200_DU_DVR3
assign dvr3_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DVR3));
`endif
`ifdef OR1200_DU_DVR4
assign dvr4_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DVR4));
`endif
`ifdef OR1200_DU_DVR5
assign dvr5_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DVR5));
`endif
`ifdef OR1200_DU_DVR6
assign dvr6_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DVR6));
`endif
`ifdef OR1200_DU_DVR7
assign dvr7_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DVR7));
`endif
`ifdef OR1200_DU_DCR0
assign dcr0_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DCR0));
`endif
`ifdef OR1200_DU_DCR1
assign dcr1_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DCR1));
`endif
`ifdef OR1200_DU_DCR2
assign dcr2_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DCR2));
`endif
`ifdef OR1200_DU_DCR3
assign dcr3_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DCR3));
`endif
`ifdef OR1200_DU_DCR4
assign dcr4_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DCR4));
`endif
`ifdef OR1200_DU_DCR5
assign dcr5_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DCR5));
`endif
`ifdef OR1200_DU_DCR6
assign dcr6_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DCR6));
`endif
`ifdef OR1200_DU_DCR7
assign dcr7_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DCR7));
`endif
`ifdef OR1200_DU_DWCR0
assign dwcr0_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DWCR0));
`endif
`ifdef OR1200_DU_DWCR1
assign dwcr1_sel = (spr_cs && (spr_addr[`OR1200_DUOFS_BITS] == `OR1200_DU_DWCR1));
`endif
// Track previous ex_freeze to detect when signals are updated
always @(posedge clk)
ex_freeze_q <= ex_freeze;
//
// Decode started exception
//
// du_except_stop comes from or1200_except
//
always @(du_except_stop or ex_freeze_q) begin
except_stop = 14'b00_0000_0000_0000;
casez (du_except_stop)
14'b1?_????_????_????:
except_stop[`OR1200_DU_DRR_TTE] = 1'b1;
14'b01_????_????_????: begin
except_stop[`OR1200_DU_DRR_IE] = 1'b1;
end
14'b00_1???_????_????: begin
except_stop[`OR1200_DU_DRR_IME] = 1'b1;
end
14'b00_01??_????_????:
except_stop[`OR1200_DU_DRR_IPFE] = 1'b1;
14'b00_001?_????_????: begin
except_stop[`OR1200_DU_DRR_BUSEE] = 1'b1;
end
14'b00_0001_????_????:
except_stop[`OR1200_DU_DRR_IIE] = 1'b1;
14'b00_0000_1???_????: begin
except_stop[`OR1200_DU_DRR_AE] = 1'b1;
end
14'b00_0000_01??_????: begin
except_stop[`OR1200_DU_DRR_DME] = 1'b1;
end
14'b00_0000_001?_????:
except_stop[`OR1200_DU_DRR_DPFE] = 1'b1;
14'b00_0000_0001_????:
except_stop[`OR1200_DU_DRR_BUSEE] = 1'b1;
14'b00_0000_0000_1???: begin
except_stop[`OR1200_DU_DRR_RE] = 1'b1;
end
14'b00_0000_0000_01??: begin
except_stop[`OR1200_DU_DRR_TE] = 1'b1 & ~ex_freeze_q;
end
14'b00_0000_0000_001?: begin
except_stop[`OR1200_DU_DRR_FPE] = 1'b1;
end
14'b00_0000_0000_0001:
except_stop[`OR1200_DU_DRR_SCE] = 1'b1 & ~ex_freeze_q;
default:
except_stop = 14'b00_0000_0000_0000;
endcase // casez (du_except_stop)
end
//
// dbg_bp_o is registered
//
assign dbg_bp_o = dbg_bp_r;
//
// Breakpoint activation register
//
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dbg_bp_r <= 1'b0;
else if (!ex_freeze)
dbg_bp_r <= |except_stop
`ifdef OR1200_DU_DMR1_ST
| ~((ex_insn[31:26] == `OR1200_OR32_NOP) & ex_insn[16]) & dmr1[`OR1200_DU_DMR1_ST]
`endif
`ifdef OR1200_DU_DMR1_BT
| (branch_op != `OR1200_BRANCHOP_NOP) & (branch_op != `OR1200_BRANCHOP_RFE) & dmr1[`OR1200_DU_DMR1_BT]
`endif
;
else
dbg_bp_r <= |except_stop;
//
// Write to DMR1
//
`ifdef OR1200_DU_DMR1
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dmr1 <= 25'h000_0000;
else if (dmr1_sel && spr_write)
`ifdef OR1200_DU_HWBKPTS
dmr1 <= spr_dat_i[24:0];
`else
dmr1 <= {1'b0, spr_dat_i[23:22], 22'h00_0000};
`endif
`else
assign dmr1 = 25'h000_0000;
`endif
//
// Write to DMR2
//
`ifdef OR1200_DU_DMR2
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dmr2 <= 24'h00_0000;
else if (dmr2_sel && spr_write)
dmr2 <= spr_dat_i[23:0];
`else
assign dmr2 = 24'h00_0000;
`endif
//
// Write to DSR
//
`ifdef OR1200_DU_DSR
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dsr <= {`OR1200_DU_DSR_WIDTH{1'b0}};
else if (dsr_sel && spr_write)
dsr <= spr_dat_i[`OR1200_DU_DSR_WIDTH-1:0];
`else
assign dsr = {`OR1200_DU_DSR_WIDTH{1'b0}};
`endif
//
// Write to DRR
//
`ifdef OR1200_DU_DRR
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
drr <= 14'b0;
else if (drr_sel && spr_write)
drr <= spr_dat_i[13:0];
else
drr <= drr | except_stop;
`else
assign drr = 14'b0;
`endif
//
// Write to DVR0
//
`ifdef OR1200_DU_DVR0
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dvr0 <= 32'h0000_0000;
else if (dvr0_sel && spr_write)
dvr0 <= spr_dat_i[31:0];
`else
assign dvr0 = 32'h0000_0000;
`endif
//
// Write to DVR1
//
`ifdef OR1200_DU_DVR1
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dvr1 <= 32'h0000_0000;
else if (dvr1_sel && spr_write)
dvr1 <= spr_dat_i[31:0];
`else
assign dvr1 = 32'h0000_0000;
`endif
//
// Write to DVR2
//
`ifdef OR1200_DU_DVR2
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dvr2 <= 32'h0000_0000;
else if (dvr2_sel && spr_write)
dvr2 <= spr_dat_i[31:0];
`else
assign dvr2 = 32'h0000_0000;
`endif
//
// Write to DVR3
//
`ifdef OR1200_DU_DVR3
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dvr3 <= 32'h0000_0000;
else if (dvr3_sel && spr_write)
dvr3 <= spr_dat_i[31:0];
`else
assign dvr3 = 32'h0000_0000;
`endif
//
// Write to DVR4
//
`ifdef OR1200_DU_DVR4
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dvr4 <= 32'h0000_0000;
else if (dvr4_sel && spr_write)
dvr4 <= spr_dat_i[31:0];
`else
assign dvr4 = 32'h0000_0000;
`endif
//
// Write to DVR5
//
`ifdef OR1200_DU_DVR5
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dvr5 <= 32'h0000_0000;
else if (dvr5_sel && spr_write)
dvr5 <= spr_dat_i[31:0];
`else
assign dvr5 = 32'h0000_0000;
`endif
//
// Write to DVR6
//
`ifdef OR1200_DU_DVR6
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dvr6 <= 32'h0000_0000;
else if (dvr6_sel && spr_write)
dvr6 <= spr_dat_i[31:0];
`else
assign dvr6 = 32'h0000_0000;
`endif
//
// Write to DVR7
//
`ifdef OR1200_DU_DVR7
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dvr7 <= 32'h0000_0000;
else if (dvr7_sel && spr_write)
dvr7 <= spr_dat_i[31:0];
`else
assign dvr7 = 32'h0000_0000;
`endif
//
// Write to DCR0
//
`ifdef OR1200_DU_DCR0
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dcr0 <= 8'h00;
else if (dcr0_sel && spr_write)
dcr0 <= spr_dat_i[7:0];
`else
assign dcr0 = 8'h00;
`endif
//
// Write to DCR1
//
`ifdef OR1200_DU_DCR1
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dcr1 <= 8'h00;
else if (dcr1_sel && spr_write)
dcr1 <= spr_dat_i[7:0];
`else
assign dcr1 = 8'h00;
`endif
//
// Write to DCR2
//
`ifdef OR1200_DU_DCR2
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dcr2 <= 8'h00;
else if (dcr2_sel && spr_write)
dcr2 <= spr_dat_i[7:0];
`else
assign dcr2 = 8'h00;
`endif
//
// Write to DCR3
//
`ifdef OR1200_DU_DCR3
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dcr3 <= 8'h00;
else if (dcr3_sel && spr_write)
dcr3 <= spr_dat_i[7:0];
`else
assign dcr3 = 8'h00;
`endif
//
// Write to DCR4
//
`ifdef OR1200_DU_DCR4
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dcr4 <= 8'h00;
else if (dcr4_sel && spr_write)
dcr4 <= spr_dat_i[7:0];
`else
assign dcr4 = 8'h00;
`endif
//
// Write to DCR5
//
`ifdef OR1200_DU_DCR5
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dcr5 <= 8'h00;
else if (dcr5_sel && spr_write)
dcr5 <= spr_dat_i[7:0];
`else
assign dcr5 = 8'h00;
`endif
//
// Write to DCR6
//
`ifdef OR1200_DU_DCR6
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dcr6 <= 8'h00;
else if (dcr6_sel && spr_write)
dcr6 <= spr_dat_i[7:0];
`else
assign dcr6 = 8'h00;
`endif
//
// Write to DCR7
//
`ifdef OR1200_DU_DCR7
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dcr7 <= 8'h00;
else if (dcr7_sel && spr_write)
dcr7 <= spr_dat_i[7:0];
`else
assign dcr7 = 8'h00;
`endif
//
// Write to DWCR0
//
`ifdef OR1200_DU_DWCR0
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dwcr0 <= 32'h0000_0000;
else if (dwcr0_sel && spr_write)
dwcr0 <= spr_dat_i[31:0];
else if (incr_wpcntr0)
dwcr0[`OR1200_DU_DWCR_COUNT] <= dwcr0[`OR1200_DU_DWCR_COUNT] + 16'h0001;
`else
assign dwcr0 = 32'h0000_0000;
`endif
//
// Write to DWCR1
//
`ifdef OR1200_DU_DWCR1
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
dwcr1 <= 32'h0000_0000;
else if (dwcr1_sel && spr_write)
dwcr1 <= spr_dat_i[31:0];
else if (incr_wpcntr1)
dwcr1[`OR1200_DU_DWCR_COUNT] <= dwcr1[`OR1200_DU_DWCR_COUNT] + 16'h0001;
`else
assign dwcr1 = 32'h0000_0000;
`endif
//
// Read DU registers
//
`ifdef OR1200_DU_READREGS
always @(spr_addr or dsr or drr or dmr1 or dmr2
or dvr0 or dvr1 or dvr2 or dvr3 or dvr4
or dvr5 or dvr6 or dvr7
or dcr0 or dcr1 or dcr2 or dcr3 or dcr4
or dcr5 or dcr6 or dcr7
or dwcr0 or dwcr1
`ifdef OR1200_DU_TB_IMPLEMENTED
or tb_wadr or tbia_dat_o or tbim_dat_o
or tbar_dat_o or tbts_dat_o
`endif
)
casez (spr_addr[`OR1200_DUOFS_BITS]) // synopsys parallel_case
`ifdef OR1200_DU_DVR0
`OR1200_DU_DVR0:
spr_dat_o = dvr0;
`endif
`ifdef OR1200_DU_DVR1
`OR1200_DU_DVR1:
spr_dat_o = dvr1;
`endif
`ifdef OR1200_DU_DVR2
`OR1200_DU_DVR2:
spr_dat_o = dvr2;
`endif
`ifdef OR1200_DU_DVR3
`OR1200_DU_DVR3:
spr_dat_o = dvr3;
`endif
`ifdef OR1200_DU_DVR4
`OR1200_DU_DVR4:
spr_dat_o = dvr4;
`endif
`ifdef OR1200_DU_DVR5
`OR1200_DU_DVR5:
spr_dat_o = dvr5;
`endif
`ifdef OR1200_DU_DVR6
`OR1200_DU_DVR6:
spr_dat_o = dvr6;
`endif
`ifdef OR1200_DU_DVR7
`OR1200_DU_DVR7:
spr_dat_o = dvr7;
`endif
`ifdef OR1200_DU_DCR0
`OR1200_DU_DCR0:
spr_dat_o = {24'h00_0000, dcr0};
`endif
`ifdef OR1200_DU_DCR1
`OR1200_DU_DCR1:
spr_dat_o = {24'h00_0000, dcr1};
`endif
`ifdef OR1200_DU_DCR2
`OR1200_DU_DCR2:
spr_dat_o = {24'h00_0000, dcr2};
`endif
`ifdef OR1200_DU_DCR3
`OR1200_DU_DCR3:
spr_dat_o = {24'h00_0000, dcr3};
`endif
`ifdef OR1200_DU_DCR4
`OR1200_DU_DCR4:
spr_dat_o = {24'h00_0000, dcr4};
`endif
`ifdef OR1200_DU_DCR5
`OR1200_DU_DCR5:
spr_dat_o = {24'h00_0000, dcr5};
`endif
`ifdef OR1200_DU_DCR6
`OR1200_DU_DCR6:
spr_dat_o = {24'h00_0000, dcr6};
`endif
`ifdef OR1200_DU_DCR7
`OR1200_DU_DCR7:
spr_dat_o = {24'h00_0000, dcr7};
`endif
`ifdef OR1200_DU_DMR1
`OR1200_DU_DMR1:
spr_dat_o = {7'h00, dmr1};
`endif
`ifdef OR1200_DU_DMR2
`OR1200_DU_DMR2:
spr_dat_o = {8'h00, dmr2};
`endif
`ifdef OR1200_DU_DWCR0
`OR1200_DU_DWCR0:
spr_dat_o = dwcr0;
`endif
`ifdef OR1200_DU_DWCR1
`OR1200_DU_DWCR1:
spr_dat_o = dwcr1;
`endif
`ifdef OR1200_DU_DSR
`OR1200_DU_DSR:
spr_dat_o = {18'b0, dsr};
`endif
`ifdef OR1200_DU_DRR
`OR1200_DU_DRR:
spr_dat_o = {18'b0, drr};
`endif
`ifdef OR1200_DU_TB_IMPLEMENTED
`OR1200_DU_TBADR:
spr_dat_o = {24'h000000, tb_wadr};
`OR1200_DU_TBIA:
spr_dat_o = tbia_dat_o;
`OR1200_DU_TBIM:
spr_dat_o = tbim_dat_o;
`OR1200_DU_TBAR:
spr_dat_o = tbar_dat_o;
`OR1200_DU_TBTS:
spr_dat_o = tbts_dat_o;
`endif
default:
spr_dat_o = 32'h0000_0000;
endcase
`endif
//
// DSR alias
//
assign du_dsr = dsr;
`ifdef OR1200_DU_HWBKPTS
//
// Compare To What (Match Condition 0)
//
always @(dcr0 or id_pc or dcpu_adr_i or dcpu_dat_dc
or dcpu_dat_lsu or dcpu_we_i)
case (dcr0[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b001: match_cond0_ct = id_pc; // insn fetch EA
3'b010: match_cond0_ct = dcpu_adr_i; // load EA
3'b011: match_cond0_ct = dcpu_adr_i; // store EA
3'b100: match_cond0_ct = dcpu_dat_dc; // load data
3'b101: match_cond0_ct = dcpu_dat_lsu; // store data
3'b110: match_cond0_ct = dcpu_adr_i; // load/store EA
default:match_cond0_ct = dcpu_we_i ? dcpu_dat_lsu : dcpu_dat_dc;
endcase
//
// When To Compare (Match Condition 0)
//
always @(dcr0 or dcpu_cycstb_i)
case (dcr0[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b000: match_cond0_stb = 1'b0; //comparison disabled
3'b001: match_cond0_stb = 1'b1; // insn fetch EA
default:match_cond0_stb = dcpu_cycstb_i; // any load/store
endcase
//
// Match Condition 0
//
always @(match_cond0_stb or dcr0 or dvr0 or match_cond0_ct)
casex ({match_cond0_stb, dcr0[`OR1200_DU_DCR_CC]})
4'b0_xxx,
4'b1_000,
4'b1_111: match0 = 1'b0;
4'b1_001: match0 =
({(match_cond0_ct[31] ^ dcr0[`OR1200_DU_DCR_SC]), match_cond0_ct[30:0]} ==
{(dvr0[31] ^ dcr0[`OR1200_DU_DCR_SC]), dvr0[30:0]});
4'b1_010: match0 =
({(match_cond0_ct[31] ^ dcr0[`OR1200_DU_DCR_SC]), match_cond0_ct[30:0]} <
{(dvr0[31] ^ dcr0[`OR1200_DU_DCR_SC]), dvr0[30:0]});
4'b1_011: match0 =
({(match_cond0_ct[31] ^ dcr0[`OR1200_DU_DCR_SC]), match_cond0_ct[30:0]} <=
{(dvr0[31] ^ dcr0[`OR1200_DU_DCR_SC]), dvr0[30:0]});
4'b1_100: match0 =
({(match_cond0_ct[31] ^ dcr0[`OR1200_DU_DCR_SC]), match_cond0_ct[30:0]} >
{(dvr0[31] ^ dcr0[`OR1200_DU_DCR_SC]), dvr0[30:0]});
4'b1_101: match0 =
({(match_cond0_ct[31] ^ dcr0[`OR1200_DU_DCR_SC]), match_cond0_ct[30:0]} >=
{(dvr0[31] ^ dcr0[`OR1200_DU_DCR_SC]), dvr0[30:0]});
4'b1_110: match0 =
({(match_cond0_ct[31] ^ dcr0[`OR1200_DU_DCR_SC]), match_cond0_ct[30:0]} !=
{(dvr0[31] ^ dcr0[`OR1200_DU_DCR_SC]), dvr0[30:0]});
endcase
//
// Watchpoint 0
//
always @(dmr1 or match0)
case (dmr1[`OR1200_DU_DMR1_CW0])
2'b00: wp[0] = match0;
2'b01: wp[0] = match0;
2'b10: wp[0] = match0;
2'b11: wp[0] = 1'b0;
endcase
//
// Compare To What (Match Condition 1)
//
always @(dcr1 or id_pc or dcpu_adr_i or dcpu_dat_dc
or dcpu_dat_lsu or dcpu_we_i)
case (dcr1[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b001: match_cond1_ct = id_pc; // insn fetch EA
3'b010: match_cond1_ct = dcpu_adr_i; // load EA
3'b011: match_cond1_ct = dcpu_adr_i; // store EA
3'b100: match_cond1_ct = dcpu_dat_dc; // load data
3'b101: match_cond1_ct = dcpu_dat_lsu; // store data
3'b110: match_cond1_ct = dcpu_adr_i; // load/store EA
default:match_cond1_ct = dcpu_we_i ? dcpu_dat_lsu : dcpu_dat_dc;
endcase
//
// When To Compare (Match Condition 1)
//
always @(dcr1 or dcpu_cycstb_i)
case (dcr1[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b000: match_cond1_stb = 1'b0; //comparison disabled
3'b001: match_cond1_stb = 1'b1; // insn fetch EA
default:match_cond1_stb = dcpu_cycstb_i; // any load/store
endcase
//
// Match Condition 1
//
always @(match_cond1_stb or dcr1 or dvr1 or match_cond1_ct)
casex ({match_cond1_stb, dcr1[`OR1200_DU_DCR_CC]})
4'b0_xxx,
4'b1_000,
4'b1_111: match1 = 1'b0;
4'b1_001: match1 =
({(match_cond1_ct[31] ^ dcr1[`OR1200_DU_DCR_SC]), match_cond1_ct[30:0]} ==
{(dvr1[31] ^ dcr1[`OR1200_DU_DCR_SC]), dvr1[30:0]});
4'b1_010: match1 =
({(match_cond1_ct[31] ^ dcr1[`OR1200_DU_DCR_SC]), match_cond1_ct[30:0]} <
{(dvr1[31] ^ dcr1[`OR1200_DU_DCR_SC]), dvr1[30:0]});
4'b1_011: match1 =
({(match_cond1_ct[31] ^ dcr1[`OR1200_DU_DCR_SC]), match_cond1_ct[30:0]} <=
{(dvr1[31] ^ dcr1[`OR1200_DU_DCR_SC]), dvr1[30:0]});
4'b1_100: match1 =
({(match_cond1_ct[31] ^ dcr1[`OR1200_DU_DCR_SC]), match_cond1_ct[30:0]} >
{(dvr1[31] ^ dcr1[`OR1200_DU_DCR_SC]), dvr1[30:0]});
4'b1_101: match1 =
({(match_cond1_ct[31] ^ dcr1[`OR1200_DU_DCR_SC]), match_cond1_ct[30:0]} >=
{(dvr1[31] ^ dcr1[`OR1200_DU_DCR_SC]), dvr1[30:0]});
4'b1_110: match1 =
({(match_cond1_ct[31] ^ dcr1[`OR1200_DU_DCR_SC]), match_cond1_ct[30:0]} !=
{(dvr1[31] ^ dcr1[`OR1200_DU_DCR_SC]), dvr1[30:0]});
endcase
//
// Watchpoint 1
//
always @(dmr1 or match1 or wp)
case (dmr1[`OR1200_DU_DMR1_CW1])
2'b00: wp[1] = match1;
2'b01: wp[1] = match1 & wp[0];
2'b10: wp[1] = match1 | wp[0];
2'b11: wp[1] = 1'b0;
endcase
//
// Compare To What (Match Condition 2)
//
always @(dcr2 or id_pc or dcpu_adr_i or dcpu_dat_dc
or dcpu_dat_lsu or dcpu_we_i)
case (dcr2[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b001: match_cond2_ct = id_pc; // insn fetch EA
3'b010: match_cond2_ct = dcpu_adr_i; // load EA
3'b011: match_cond2_ct = dcpu_adr_i; // store EA
3'b100: match_cond2_ct = dcpu_dat_dc; // load data
3'b101: match_cond2_ct = dcpu_dat_lsu; // store data
3'b110: match_cond2_ct = dcpu_adr_i; // load/store EA
default:match_cond2_ct = dcpu_we_i ? dcpu_dat_lsu : dcpu_dat_dc;
endcase
//
// When To Compare (Match Condition 2)
//
always @(dcr2 or dcpu_cycstb_i)
case (dcr2[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b000: match_cond2_stb = 1'b0; //comparison disabled
3'b001: match_cond2_stb = 1'b1; // insn fetch EA
default:match_cond2_stb = dcpu_cycstb_i; // any load/store
endcase
//
// Match Condition 2
//
always @(match_cond2_stb or dcr2 or dvr2 or match_cond2_ct)
casex ({match_cond2_stb, dcr2[`OR1200_DU_DCR_CC]})
4'b0_xxx,
4'b1_000,
4'b1_111: match2 = 1'b0;
4'b1_001: match2 =
({(match_cond2_ct[31] ^ dcr2[`OR1200_DU_DCR_SC]), match_cond2_ct[30:0]} ==
{(dvr2[31] ^ dcr2[`OR1200_DU_DCR_SC]), dvr2[30:0]});
4'b1_010: match2 =
({(match_cond2_ct[31] ^ dcr2[`OR1200_DU_DCR_SC]), match_cond2_ct[30:0]} <
{(dvr2[31] ^ dcr2[`OR1200_DU_DCR_SC]), dvr2[30:0]});
4'b1_011: match2 =
({(match_cond2_ct[31] ^ dcr2[`OR1200_DU_DCR_SC]), match_cond2_ct[30:0]} <=
{(dvr2[31] ^ dcr2[`OR1200_DU_DCR_SC]), dvr2[30:0]});
4'b1_100: match2 =
({(match_cond2_ct[31] ^ dcr2[`OR1200_DU_DCR_SC]), match_cond2_ct[30:0]} >
{(dvr2[31] ^ dcr2[`OR1200_DU_DCR_SC]), dvr2[30:0]});
4'b1_101: match2 =
({(match_cond2_ct[31] ^ dcr2[`OR1200_DU_DCR_SC]), match_cond2_ct[30:0]} >=
{(dvr2[31] ^ dcr2[`OR1200_DU_DCR_SC]), dvr2[30:0]});
4'b1_110: match2 =
({(match_cond2_ct[31] ^ dcr2[`OR1200_DU_DCR_SC]), match_cond2_ct[30:0]} !=
{(dvr2[31] ^ dcr2[`OR1200_DU_DCR_SC]), dvr2[30:0]});
endcase
//
// Watchpoint 2
//
always @(dmr1 or match2 or wp)
case (dmr1[`OR1200_DU_DMR1_CW2])
2'b00: wp[2] = match2;
2'b01: wp[2] = match2 & wp[1];
2'b10: wp[2] = match2 | wp[1];
2'b11: wp[2] = 1'b0;
endcase
//
// Compare To What (Match Condition 3)
//
always @(dcr3 or id_pc or dcpu_adr_i or dcpu_dat_dc
or dcpu_dat_lsu or dcpu_we_i)
case (dcr3[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b001: match_cond3_ct = id_pc; // insn fetch EA
3'b010: match_cond3_ct = dcpu_adr_i; // load EA
3'b011: match_cond3_ct = dcpu_adr_i; // store EA
3'b100: match_cond3_ct = dcpu_dat_dc; // load data
3'b101: match_cond3_ct = dcpu_dat_lsu; // store data
3'b110: match_cond3_ct = dcpu_adr_i; // load/store EA
default:match_cond3_ct = dcpu_we_i ? dcpu_dat_lsu : dcpu_dat_dc;
endcase
//
// When To Compare (Match Condition 3)
//
always @(dcr3 or dcpu_cycstb_i)
case (dcr3[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b000: match_cond3_stb = 1'b0; //comparison disabled
3'b001: match_cond3_stb = 1'b1; // insn fetch EA
default:match_cond3_stb = dcpu_cycstb_i; // any load/store
endcase
//
// Match Condition 3
//
always @(match_cond3_stb or dcr3 or dvr3 or match_cond3_ct)
casex ({match_cond3_stb, dcr3[`OR1200_DU_DCR_CC]})
4'b0_xxx,
4'b1_000,
4'b1_111: match3 = 1'b0;
4'b1_001: match3 =
({(match_cond3_ct[31] ^ dcr3[`OR1200_DU_DCR_SC]), match_cond3_ct[30:0]} ==
{(dvr3[31] ^ dcr3[`OR1200_DU_DCR_SC]), dvr3[30:0]});
4'b1_010: match3 =
({(match_cond3_ct[31] ^ dcr3[`OR1200_DU_DCR_SC]), match_cond3_ct[30:0]} <
{(dvr3[31] ^ dcr3[`OR1200_DU_DCR_SC]), dvr3[30:0]});
4'b1_011: match3 =
({(match_cond3_ct[31] ^ dcr3[`OR1200_DU_DCR_SC]), match_cond3_ct[30:0]} <=
{(dvr3[31] ^ dcr3[`OR1200_DU_DCR_SC]), dvr3[30:0]});
4'b1_100: match3 =
({(match_cond3_ct[31] ^ dcr3[`OR1200_DU_DCR_SC]), match_cond3_ct[30:0]} >
{(dvr3[31] ^ dcr3[`OR1200_DU_DCR_SC]), dvr3[30:0]});
4'b1_101: match3 =
({(match_cond3_ct[31] ^ dcr3[`OR1200_DU_DCR_SC]), match_cond3_ct[30:0]} >=
{(dvr3[31] ^ dcr3[`OR1200_DU_DCR_SC]), dvr3[30:0]});
4'b1_110: match3 =
({(match_cond3_ct[31] ^ dcr3[`OR1200_DU_DCR_SC]), match_cond3_ct[30:0]} !=
{(dvr3[31] ^ dcr3[`OR1200_DU_DCR_SC]), dvr3[30:0]});
endcase
//
// Watchpoint 3
//
always @(dmr1 or match3 or wp)
case (dmr1[`OR1200_DU_DMR1_CW3])
2'b00: wp[3] = match3;
2'b01: wp[3] = match3 & wp[2];
2'b10: wp[3] = match3 | wp[2];
2'b11: wp[3] = 1'b0;
endcase
//
// Compare To What (Match Condition 4)
//
always @(dcr4 or id_pc or dcpu_adr_i or dcpu_dat_dc
or dcpu_dat_lsu or dcpu_we_i)
case (dcr4[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b001: match_cond4_ct = id_pc; // insn fetch EA
3'b010: match_cond4_ct = dcpu_adr_i; // load EA
3'b011: match_cond4_ct = dcpu_adr_i; // store EA
3'b100: match_cond4_ct = dcpu_dat_dc; // load data
3'b101: match_cond4_ct = dcpu_dat_lsu; // store data
3'b110: match_cond4_ct = dcpu_adr_i; // load/store EA
default:match_cond4_ct = dcpu_we_i ? dcpu_dat_lsu : dcpu_dat_dc;
endcase
//
// When To Compare (Match Condition 4)
//
always @(dcr4 or dcpu_cycstb_i)
case (dcr4[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b000: match_cond4_stb = 1'b0; //comparison disabled
3'b001: match_cond4_stb = 1'b1; // insn fetch EA
default:match_cond4_stb = dcpu_cycstb_i; // any load/store
endcase
//
// Match Condition 4
//
always @(match_cond4_stb or dcr4 or dvr4 or match_cond4_ct)
casex ({match_cond4_stb, dcr4[`OR1200_DU_DCR_CC]})
4'b0_xxx,
4'b1_000,
4'b1_111: match4 = 1'b0;
4'b1_001: match4 =
({(match_cond4_ct[31] ^ dcr4[`OR1200_DU_DCR_SC]), match_cond4_ct[30:0]} ==
{(dvr4[31] ^ dcr4[`OR1200_DU_DCR_SC]), dvr4[30:0]});
4'b1_010: match4 =
({(match_cond4_ct[31] ^ dcr4[`OR1200_DU_DCR_SC]), match_cond4_ct[30:0]} <
{(dvr4[31] ^ dcr4[`OR1200_DU_DCR_SC]), dvr4[30:0]});
4'b1_011: match4 =
({(match_cond4_ct[31] ^ dcr4[`OR1200_DU_DCR_SC]), match_cond4_ct[30:0]} <=
{(dvr4[31] ^ dcr4[`OR1200_DU_DCR_SC]), dvr4[30:0]});
4'b1_100: match4 =
({(match_cond4_ct[31] ^ dcr4[`OR1200_DU_DCR_SC]), match_cond4_ct[30:0]} >
{(dvr4[31] ^ dcr4[`OR1200_DU_DCR_SC]), dvr4[30:0]});
4'b1_101: match4 =
({(match_cond4_ct[31] ^ dcr4[`OR1200_DU_DCR_SC]), match_cond4_ct[30:0]} >=
{(dvr4[31] ^ dcr4[`OR1200_DU_DCR_SC]), dvr4[30:0]});
4'b1_110: match4 =
({(match_cond4_ct[31] ^ dcr4[`OR1200_DU_DCR_SC]), match_cond4_ct[30:0]} !=
{(dvr4[31] ^ dcr4[`OR1200_DU_DCR_SC]), dvr4[30:0]});
endcase
//
// Watchpoint 4
//
always @(dmr1 or match4 or wp)
case (dmr1[`OR1200_DU_DMR1_CW4])
2'b00: wp[4] = match4;
2'b01: wp[4] = match4 & wp[3];
2'b10: wp[4] = match4 | wp[3];
2'b11: wp[4] = 1'b0;
endcase
//
// Compare To What (Match Condition 5)
//
always @(dcr5 or id_pc or dcpu_adr_i or dcpu_dat_dc
or dcpu_dat_lsu or dcpu_we_i)
case (dcr5[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b001: match_cond5_ct = id_pc; // insn fetch EA
3'b010: match_cond5_ct = dcpu_adr_i; // load EA
3'b011: match_cond5_ct = dcpu_adr_i; // store EA
3'b100: match_cond5_ct = dcpu_dat_dc; // load data
3'b101: match_cond5_ct = dcpu_dat_lsu; // store data
3'b110: match_cond5_ct = dcpu_adr_i; // load/store EA
default:match_cond5_ct = dcpu_we_i ? dcpu_dat_lsu : dcpu_dat_dc;
endcase
//
// When To Compare (Match Condition 5)
//
always @(dcr5 or dcpu_cycstb_i)
case (dcr5[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b000: match_cond5_stb = 1'b0; //comparison disabled
3'b001: match_cond5_stb = 1'b1; // insn fetch EA
default:match_cond5_stb = dcpu_cycstb_i; // any load/store
endcase
//
// Match Condition 5
//
always @(match_cond5_stb or dcr5 or dvr5 or match_cond5_ct)
casex ({match_cond5_stb, dcr5[`OR1200_DU_DCR_CC]})
4'b0_xxx,
4'b1_000,
4'b1_111: match5 = 1'b0;
4'b1_001: match5 =
({(match_cond5_ct[31] ^ dcr5[`OR1200_DU_DCR_SC]), match_cond5_ct[30:0]} ==
{(dvr5[31] ^ dcr5[`OR1200_DU_DCR_SC]), dvr5[30:0]});
4'b1_010: match5 =
({(match_cond5_ct[31] ^ dcr5[`OR1200_DU_DCR_SC]), match_cond5_ct[30:0]} <
{(dvr5[31] ^ dcr5[`OR1200_DU_DCR_SC]), dvr5[30:0]});
4'b1_011: match5 =
({(match_cond5_ct[31] ^ dcr5[`OR1200_DU_DCR_SC]), match_cond5_ct[30:0]} <=
{(dvr5[31] ^ dcr5[`OR1200_DU_DCR_SC]), dvr5[30:0]});
4'b1_100: match5 =
({(match_cond5_ct[31] ^ dcr5[`OR1200_DU_DCR_SC]), match_cond5_ct[30:0]} >
{(dvr5[31] ^ dcr5[`OR1200_DU_DCR_SC]), dvr5[30:0]});
4'b1_101: match5 =
({(match_cond5_ct[31] ^ dcr5[`OR1200_DU_DCR_SC]), match_cond5_ct[30:0]} >=
{(dvr5[31] ^ dcr5[`OR1200_DU_DCR_SC]), dvr5[30:0]});
4'b1_110: match5 =
({(match_cond5_ct[31] ^ dcr5[`OR1200_DU_DCR_SC]), match_cond5_ct[30:0]} !=
{(dvr5[31] ^ dcr5[`OR1200_DU_DCR_SC]), dvr5[30:0]});
endcase
//
// Watchpoint 5
//
always @(dmr1 or match5 or wp)
case (dmr1[`OR1200_DU_DMR1_CW5])
2'b00: wp[5] = match5;
2'b01: wp[5] = match5 & wp[4];
2'b10: wp[5] = match5 | wp[4];
2'b11: wp[5] = 1'b0;
endcase
//
// Compare To What (Match Condition 6)
//
always @(dcr6 or id_pc or dcpu_adr_i or dcpu_dat_dc
or dcpu_dat_lsu or dcpu_we_i)
case (dcr6[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b001: match_cond6_ct = id_pc; // insn fetch EA
3'b010: match_cond6_ct = dcpu_adr_i; // load EA
3'b011: match_cond6_ct = dcpu_adr_i; // store EA
3'b100: match_cond6_ct = dcpu_dat_dc; // load data
3'b101: match_cond6_ct = dcpu_dat_lsu; // store data
3'b110: match_cond6_ct = dcpu_adr_i; // load/store EA
default:match_cond6_ct = dcpu_we_i ? dcpu_dat_lsu : dcpu_dat_dc;
endcase
//
// When To Compare (Match Condition 6)
//
always @(dcr6 or dcpu_cycstb_i)
case (dcr6[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b000: match_cond6_stb = 1'b0; //comparison disabled
3'b001: match_cond6_stb = 1'b1; // insn fetch EA
default:match_cond6_stb = dcpu_cycstb_i; // any load/store
endcase
//
// Match Condition 6
//
always @(match_cond6_stb or dcr6 or dvr6 or match_cond6_ct)
casex ({match_cond6_stb, dcr6[`OR1200_DU_DCR_CC]})
4'b0_xxx,
4'b1_000,
4'b1_111: match6 = 1'b0;
4'b1_001: match6 =
({(match_cond6_ct[31] ^ dcr6[`OR1200_DU_DCR_SC]), match_cond6_ct[30:0]} ==
{(dvr6[31] ^ dcr6[`OR1200_DU_DCR_SC]), dvr6[30:0]});
4'b1_010: match6 =
({(match_cond6_ct[31] ^ dcr6[`OR1200_DU_DCR_SC]), match_cond6_ct[30:0]} <
{(dvr6[31] ^ dcr6[`OR1200_DU_DCR_SC]), dvr6[30:0]});
4'b1_011: match6 =
({(match_cond6_ct[31] ^ dcr6[`OR1200_DU_DCR_SC]), match_cond6_ct[30:0]} <=
{(dvr6[31] ^ dcr6[`OR1200_DU_DCR_SC]), dvr6[30:0]});
4'b1_100: match6 =
({(match_cond6_ct[31] ^ dcr6[`OR1200_DU_DCR_SC]), match_cond6_ct[30:0]} >
{(dvr6[31] ^ dcr6[`OR1200_DU_DCR_SC]), dvr6[30:0]});
4'b1_101: match6 =
({(match_cond6_ct[31] ^ dcr6[`OR1200_DU_DCR_SC]), match_cond6_ct[30:0]} >=
{(dvr6[31] ^ dcr6[`OR1200_DU_DCR_SC]), dvr6[30:0]});
4'b1_110: match6 =
({(match_cond6_ct[31] ^ dcr6[`OR1200_DU_DCR_SC]), match_cond6_ct[30:0]} !=
{(dvr6[31] ^ dcr6[`OR1200_DU_DCR_SC]), dvr6[30:0]});
endcase
//
// Watchpoint 6
//
always @(dmr1 or match6 or wp)
case (dmr1[`OR1200_DU_DMR1_CW6])
2'b00: wp[6] = match6;
2'b01: wp[6] = match6 & wp[5];
2'b10: wp[6] = match6 | wp[5];
2'b11: wp[6] = 1'b0;
endcase
//
// Compare To What (Match Condition 7)
//
always @(dcr7 or id_pc or dcpu_adr_i or dcpu_dat_dc
or dcpu_dat_lsu or dcpu_we_i)
case (dcr7[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b001: match_cond7_ct = id_pc; // insn fetch EA
3'b010: match_cond7_ct = dcpu_adr_i; // load EA
3'b011: match_cond7_ct = dcpu_adr_i; // store EA
3'b100: match_cond7_ct = dcpu_dat_dc; // load data
3'b101: match_cond7_ct = dcpu_dat_lsu; // store data
3'b110: match_cond7_ct = dcpu_adr_i; // load/store EA
default:match_cond7_ct = dcpu_we_i ? dcpu_dat_lsu : dcpu_dat_dc;
endcase
//
// When To Compare (Match Condition 7)
//
always @(dcr7 or dcpu_cycstb_i)
case (dcr7[`OR1200_DU_DCR_CT]) // synopsys parallel_case
3'b000: match_cond7_stb = 1'b0; //comparison disabled
3'b001: match_cond7_stb = 1'b1; // insn fetch EA
default:match_cond7_stb = dcpu_cycstb_i; // any load/store
endcase
//
// Match Condition 7
//
always @(match_cond7_stb or dcr7 or dvr7 or match_cond7_ct)
casex ({match_cond7_stb, dcr7[`OR1200_DU_DCR_CC]})
4'b0_xxx,
4'b1_000,
4'b1_111: match7 = 1'b0;
4'b1_001: match7 =
({(match_cond7_ct[31] ^ dcr7[`OR1200_DU_DCR_SC]), match_cond7_ct[30:0]} ==
{(dvr7[31] ^ dcr7[`OR1200_DU_DCR_SC]), dvr7[30:0]});
4'b1_010: match7 =
({(match_cond7_ct[31] ^ dcr7[`OR1200_DU_DCR_SC]), match_cond7_ct[30:0]} <
{(dvr7[31] ^ dcr7[`OR1200_DU_DCR_SC]), dvr7[30:0]});
4'b1_011: match7 =
({(match_cond7_ct[31] ^ dcr7[`OR1200_DU_DCR_SC]), match_cond7_ct[30:0]} <=
{(dvr7[31] ^ dcr7[`OR1200_DU_DCR_SC]), dvr7[30:0]});
4'b1_100: match7 =
({(match_cond7_ct[31] ^ dcr7[`OR1200_DU_DCR_SC]), match_cond7_ct[30:0]} >
{(dvr7[31] ^ dcr7[`OR1200_DU_DCR_SC]), dvr7[30:0]});
4'b1_101: match7 =
({(match_cond7_ct[31] ^ dcr7[`OR1200_DU_DCR_SC]), match_cond7_ct[30:0]} >=
{(dvr7[31] ^ dcr7[`OR1200_DU_DCR_SC]), dvr7[30:0]});
4'b1_110: match7 =
({(match_cond7_ct[31] ^ dcr7[`OR1200_DU_DCR_SC]), match_cond7_ct[30:0]} !=
{(dvr7[31] ^ dcr7[`OR1200_DU_DCR_SC]), dvr7[30:0]});
endcase
//
// Watchpoint 7
//
always @(dmr1 or match7 or wp)
case (dmr1[`OR1200_DU_DMR1_CW7])
2'b00: wp[7] = match7;
2'b01: wp[7] = match7 & wp[6];
2'b10: wp[7] = match7 | wp[6];
2'b11: wp[7] = 1'b0;
endcase
//
// Increment Watchpoint Counter 0
//
always @(wp or dmr2)
if (dmr2[`OR1200_DU_DMR2_WCE0])
incr_wpcntr0 = |(wp & ~dmr2[`OR1200_DU_DMR2_AWTC]);
else
incr_wpcntr0 = 1'b0;
//
// Match Condition Watchpoint Counter 0
//
always @(dwcr0)
if (dwcr0[`OR1200_DU_DWCR_MATCH] == dwcr0[`OR1200_DU_DWCR_COUNT])
wpcntr0_match = 1'b1;
else
wpcntr0_match = 1'b0;
//
// Watchpoint 8
//
always @(dmr1 or wpcntr0_match or wp)
case (dmr1[`OR1200_DU_DMR1_CW8])
2'b00: wp[8] = wpcntr0_match;
2'b01: wp[8] = wpcntr0_match & wp[7];
2'b10: wp[8] = wpcntr0_match | wp[7];
2'b11: wp[8] = 1'b0;
endcase
//
// Increment Watchpoint Counter 1
//
always @(wp or dmr2)
if (dmr2[`OR1200_DU_DMR2_WCE1])
incr_wpcntr1 = |(wp & dmr2[`OR1200_DU_DMR2_AWTC]);
else
incr_wpcntr1 = 1'b0;
//
// Match Condition Watchpoint Counter 1
//
always @(dwcr1)
if (dwcr1[`OR1200_DU_DWCR_MATCH] == dwcr1[`OR1200_DU_DWCR_COUNT])
wpcntr1_match = 1'b1;
else
wpcntr1_match = 1'b0;
//
// Watchpoint 9
//
always @(dmr1 or wpcntr1_match or wp)
case (dmr1[`OR1200_DU_DMR1_CW9])
2'b00: wp[9] = wpcntr1_match;
2'b01: wp[9] = wpcntr1_match & wp[8];
2'b10: wp[9] = wpcntr1_match | wp[8];
2'b11: wp[9] = 1'b0;
endcase
//
// Watchpoint 10
//
always @(dmr1 or dbg_ewt_i or wp)
case (dmr1[`OR1200_DU_DMR1_CW10])
2'b00: wp[10] = dbg_ewt_i;
2'b01: wp[10] = dbg_ewt_i & wp[9];
2'b10: wp[10] = dbg_ewt_i | wp[9];
2'b11: wp[10] = 1'b0;
endcase
`endif
//
// Watchpoints can cause trap exception
//
`ifdef OR1200_DU_HWBKPTS
assign du_hwbkpt = |(wp & dmr2[`OR1200_DU_DMR2_WGB]) | du_hwbkpt_hold | (dbg_bp_r & ~dsr[`OR1200_DU_DSR_TE]);
`else
assign du_hwbkpt = 1'b0;
`endif
// Hold du_hwbkpt if ex_freeze is active in order to cause trap exception
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
du_hwbkpt_hold <= 1'b0;
else if (du_hwbkpt & ex_freeze)
du_hwbkpt_hold <= 1'b1;
else if (!ex_freeze)
du_hwbkpt_hold <= 1'b0;
`ifdef OR1200_DU_TB_IMPLEMENTED
//
// Simple trace buffer
// (right now hardcoded for Xilinx Virtex FPGAs)
//
// Stores last 256 instruction addresses, instruction
// machine words and ALU results
//
//
// Trace buffer write enable
//
assign tb_enw = ~ex_freeze & ~((ex_insn[31:26] == `OR1200_OR32_NOP) & ex_insn[16]);
//
// Trace buffer write address pointer
//
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
tb_wadr <= 8'h00;
else if (tb_enw)
tb_wadr <= tb_wadr + 8'd1;
//
// Free running counter (time stamp)
//
always @(posedge clk or `OR1200_RST_EVENT rst)
if (rst == `OR1200_RST_VALUE)
tb_timstmp <= 32'h00000000;
else if (!dbg_bp_r)
tb_timstmp <= tb_timstmp + 32'd1;
//
// Trace buffer RAMs
//
or1200_dpram_256x32 tbia_ram(
.clk_a(clk),
.rst_a(1'b0),
.addr_a(spr_addr[7:0]),
.ce_a(1'b1),
.oe_a(1'b1),
.do_a(tbia_dat_o),
.clk_b(clk),
.rst_b(1'b0),
.addr_b(tb_wadr),
.di_b(spr_dat_npc),
.ce_b(1'b1),
.we_b(tb_enw)
);
or1200_dpram_256x32 tbim_ram(
.clk_a(clk),
.rst_a(1'b0),
.addr_a(spr_addr[7:0]),
.ce_a(1'b1),
.oe_a(1'b1),
.do_a(tbim_dat_o),
.clk_b(clk),
.rst_b(1'b0),
.addr_b(tb_wadr),
.di_b(ex_insn),
.ce_b(1'b1),
.we_b(tb_enw)
);
or1200_dpram_256x32 tbar_ram(
.clk_a(clk),
.rst_a(1'b0),
.addr_a(spr_addr[7:0]),
.ce_a(1'b1),
.oe_a(1'b1),
.do_a(tbar_dat_o),
.clk_b(clk),
.rst_b(1'b0),
.addr_b(tb_wadr),
.di_b(rf_dataw),
.ce_b(1'b1),
.we_b(tb_enw)
);
or1200_dpram_256x32 tbts_ram(
.clk_a(clk),
.rst_a(1'b0),
.addr_a(spr_addr[7:0]),
.ce_a(1'b1),
.oe_a(1'b1),
.do_a(tbts_dat_o),
.clk_b(clk),
.rst_b(1'b0),
.addr_b(tb_wadr),
.di_b(tb_timstmp),
.ce_b(1'b1),
.we_b(tb_enw)
);
`else
assign tbia_dat_o = 32'h0000_0000;
assign tbim_dat_o = 32'h0000_0000;
assign tbar_dat_o = 32'h0000_0000;
assign tbts_dat_o = 32'h0000_0000;
`endif // OR1200_DU_TB_IMPLEMENTED
`else // OR1200_DU_IMPLEMENTED
//
// When DU is not implemented, drive all outputs as would when DU is disabled
//
assign dbg_bp_o = 1'b0;
assign du_dsr = {`OR1200_DU_DSR_WIDTH{1'b0}};
assign du_dmr1 = {25{1'b0}};
assign du_hwbkpt = 1'b0;
//
// Read DU registers
//
`ifdef OR1200_DU_READREGS
assign spr_dat_o = 32'h0000_0000;
`ifdef OR1200_DU_UNUSED_ZERO
`endif
`endif
`endif
endmodule
diff --git a/autotests/input/syntax/vhdl/results/light52_muldiv.vhdl.reference.html b/autotests/input/syntax/vhdl/results/light52_muldiv.vhdl.reference.html
index d0cc524e..af2fd1c7 100644
--- a/autotests/input/syntax/vhdl/results/light52_muldiv.vhdl.reference.html
+++ b/autotests/input/syntax/vhdl/results/light52_muldiv.vhdl.reference.html
@@ -1,253 +1,253 @@
light52_muldiv.vhdl
-
+
--------------------------------------------------------------------------------
-- light52_muldiv.vhdl -- Simple multiplier/divider module.
--------------------------------------------------------------------------------
-- The 8051 mul and div instructions are both unsigned and operands are 8 bit.
--
-- This module implements the division as a sequential state machine which takes
-- 8 cycles to complete.
-- The multiplier can be implemented as sequential or as combinational, in which
-- case it will use a DSP block in those architectures that support it.
-- No attempt has been made to make this module generic or reusable.
--
-- If you want a combinational multiplier but don't want to waste a DSP block
-- in this module, you need to modify this file adding whatever synthesis
-- pragmas your tool of choice needs.
--
-- Note that unlike the division state machine, the combinational product logic
-- is always operating: when SEQUENTIAL_MULTIPLIER=true, prod_out equals
-- data_a * data_b with a latency of 1 clock cycle, and mul_ready is hardwired
-- to '1'.
--
-- FIXME explain division algorithm.
--------------------------------------------------------------------------------
-- GENERICS:
--
-- SEQUENTIAL_MULTIPLIER -- Sequential vs. combinational multiplier.
-- When true, a sequential implementation will be used for the multiplier,
-- which will usually save a lot of logic or a dedicated multiplier.
-- When false, a combinational registered multiplier will be used.
--
--------------------------------------------------------------------------------
-- INTERFACE SIGNALS:
--
-- clk : Clock, active rising edge.
-- reset : Synchronous reset. Clears only the control registers not
-- visible to the programmer -- not the output registers.
--
-- data_a : Numerator input, should be connected to the ACC register.
-- data_b : Denominator input, should be connected to the B register.
-- start : Assert for 1 cycle to start the division state machine
-- (and the product if SEQUENTIAL_MULTIPLIER=true);
--
-- prod_out : Product output, valid only when mul_ready='1'.
-- quot_out : Quotient output, valid only when div_ready='1'.
-- rem_out : Remainder output, valid only when div_ready='1'.
-- div_ov_out : Division overflow flag, valid only when div_ready='1'.
-- mul_ov_out : Product overflow flag, valid only when mul_ready='1'.
--
-- mul_ready : Asserted permanently if SEQUENTIAL_MULTIPLIER=false.
-- div_ready : Deasserted the cycle after start is asserted.
-- Asserted when the division has completed.
--
--------------------------------------------------------------------------------
-- Copyright (C) 2012 Jose A. Ruiz
--
-- This source file may be used and distributed without
-- restriction provided that this copyright statement is not
-- removed from the file and that any derivative work contains
-- the original copyright notice and the associated disclaimer.
--
-- This source file is free software; you can redistribute it
-- and/or modify it under the terms of the GNU Lesser General
-- Public License as published by the Free Software Foundation;
-- either version 2.1 of the License, or (at your option) any
-- later version.
--
-- This source 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 Lesser General Public License for more
-- details.
--
-- You should have received a copy of the GNU Lesser General
-- Public License along with this source; if not, download it
-- from http://www.opencores.org/lgpl.shtml
--------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.light52_pkg.all;
use work.light52_ucode_pkg.all;
entity light52_muldiv is
generic (
SEQUENTIAL_MULTIPLIER : boolean := false
);
port(
clk : in std_logic;
reset : in std_logic;
data_a : in t_byte;
data_b : in t_byte;
start : in std_logic;
prod_out : out t_word;
quot_out : out t_byte;
rem_out : out t_byte;
div_ov_out : out std_logic;
mul_ov_out : out std_logic;
mul_ready : out std_logic;
div_ready : out std_logic
);
end entity light52_muldiv;
architecture sequential of light52_muldiv is
signal bit_ctr : integer range 0 to 8;
signal b_shift_reg : t_word;
signal den_ge_256 : std_logic;
signal num_ge_den : std_logic;
signal sub_num : std_logic;
signal denominator : t_byte;
signal rem_reg : t_byte;
signal quot_reg : t_byte;
signal prod_reg : t_word;
signal ready : std_logic;
signal load_regs : std_logic;
begin
-- Control logic ---------------------------------------------------------------
control_counter: process(clk)
begin
if clk'event and clk='1' then
if reset='1' then
bit_ctr <= 8;
else
if load_regs='1' then
bit_ctr <= 0;
elsif bit_ctr /= 8 then
bit_ctr <= bit_ctr + 1;
end if;
end if;
end if;
end process control_counter;
-- Internal signal ready is asserted after 8 cycles.
-- The sequential multiplier will use this signal too, IF it takes 8 cycles.
ready <= '1' when bit_ctr >= 8 else '0';
---- Divider logic -------------------------------------------------------------
-- What we do is a simple base-2 'shift-and-subtract' algorithm that takes
-- 8 cycles to complete. We can get away with this because we deal with unsigned
-- numbers only.
divider_registers: process(clk)
begin
if clk'event and clk='1' then
-- denominator shift register
if load_regs='1' then
b_shift_reg <= "0" & data_b & "0000000";
-- Division overflow can be determined upon loading B reg data.
-- OV will be raised only on div-by-zero.
if data_b=X"00" then
div_ov_out <= '1';
else
div_ov_out <= '0';
end if;
else
b_shift_reg <= "0" & b_shift_reg(b_shift_reg'high downto 1);
end if;
-- numerator register
if load_regs='1' then
rem_reg <= data_a;
elsif bit_ctr/=8 and sub_num='1' then
rem_reg <= rem_reg - denominator;
end if;
--- quotient register
if load_regs='1' then
quot_reg <= (others => '0');
elsif bit_ctr/=8 then
quot_reg <= quot_reg(quot_reg'high-1 downto 0) & sub_num;
end if;
load_regs <= start;
end if;
end process divider_registers;
denominator <= b_shift_reg(7 downto 0);
-- The 16-bit comparison between b_shift_reg (denominator) and the zero-extended
-- rem_reg (numerator) can be simplified by splitting it in 2:
-- If the shifted denominator high byte is not zero, it is >=256...
den_ge_256 <= '1' when b_shift_reg(15 downto 8) /= X"00" else '0';
-- ...otherwise we need to compare the low bytes.
num_ge_den <= '1' when rem_reg >= denominator else '0';
sub_num <= '1' when den_ge_256='0' and num_ge_den='1' else '0';
quot_out <= quot_reg;
prod_out <= prod_reg;
rem_out <= rem_reg;
div_ready <= ready;
---- Multiplier logic ----------------------------------------------------------
---- Combinational multiplier -----------------------------
multiplier_combinational: if not SEQUENTIAL_MULTIPLIER generate
registered_combinational_multiplier:process(clk)
begin
if clk'event and clk='1' then
prod_reg <= data_a * data_b; -- t_byte is unsigned
end if;
end process registered_combinational_multiplier;
-- The multiplier output is valid in the cycle after the operands are loaded,
-- so by the time MUL is executed it's already done.
mul_ready <= '1';
mul_ov_out <= '1' when prod_reg(15 downto 8)/=X"00" else '0';
prod_out <= prod_reg;
end generate multiplier_combinational;
---- Sequential multiplier --------------------------------
multiplier_sequential: if SEQUENTIAL_MULTIPLIER generate
assert false
report "Sequential multiplier implementation not done yet."&
" Use combinational implementation."
severity failure;
end generate multiplier_sequential;
end sequential;
diff --git a/autotests/input/syntax/vhdl/results/light52_tb.vhdl.reference.html b/autotests/input/syntax/vhdl/results/light52_tb.vhdl.reference.html
index 0fac92bf..20a6209d 100644
--- a/autotests/input/syntax/vhdl/results/light52_tb.vhdl.reference.html
+++ b/autotests/input/syntax/vhdl/results/light52_tb.vhdl.reference.html
@@ -1,194 +1,194 @@
light52_tb.vhdl
-
+
--------------------------------------------------------------------------------
-- light52_tb.vhdl --
--------------------------------------------------------------------------------
-- This test bench simulates the execution of some program (whose object code
-- is in package obj_code_pkg, in the form of a memory init constant) and logs
-- the execution to a text file called 'hw_sim_log.txt' (light52_tb_pkg.vhdl).
--
-- This test bench does no actual tests on the core. Instead, the simulation log
-- is meant to be matched against the simulation log produced by running the
-- same program on the software simulator B51 (also included with this project).
--
-- This will catch errors in the implementation of the CPU if the simulated
-- program has anough coverage -- the opcode tester is meant to cover all CPU
-- opcodes in many (not all) of their corner cases.
-- This scheme will not help in catching errors in the peripheral modules,
-- mainly because the current version of B51 does not simulate them.
--
--------------------------------------------------------------------------------
-- Copyright (C) 2012 Jose A. Ruiz
--
-- This source file may be used and distributed without
-- restriction provided that this copyright statement is not
-- removed from the file and that any derivative work contains
-- the original copyright notice and the associated disclaimer.
--
-- This source file is free software; you can redistribute it
-- and/or modify it under the terms of the GNU Lesser General
-- Public License as published by the Free Software Foundation;
-- either version 2.1 of the License, or (at your option) any
-- later version.
--
-- This source 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 Lesser General Public License for more
-- details.
--
-- You should have received a copy of the GNU Lesser General
-- Public License along with this source; if not, download it
-- from http://www.opencores.org/lgpl.shtml
--------------------------------------------------------------------------------
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
use std.textio.all;
use work.light52_pkg.all;
use work.obj_code_pkg.all;
use work.light52_tb_pkg.all;
use work.txt_util.all;
entity light52_tb is
generic (BCD : boolean := true);
end;
architecture testbench of light52_tb is
--------------------------------------------------------------------------------
-- Simulation parameters
-- FIXME these should be in parameter package
-- Simulated clock period is the same as the usual target, the DE-1 board
constant T : time := 20 ns; -- 50MHz
constant SIMULATION_LENGTH : integer := 400000;
--------------------------------------------------------------------------------
-- MPU interface
signal clk : std_logic := '0';
signal reset : std_logic := '1';
signal p0_out : std_logic_vector(7 downto 0);
signal p1_out : std_logic_vector(7 downto 0);
signal p2_in : std_logic_vector(7 downto 0);
signal p3_in : std_logic_vector(7 downto 0);
signal external_irq : std_logic_vector(7 downto 0);
signal txd, rxd : std_logic;
--------------------------------------------------------------------------------
-- Logging signals & simulation control
-- Asserted high to disable the clock and terminate the simulation.
signal done : std_logic := '0';
-- Log file
file log_file: TEXT open write_mode is "hw_sim_log.txt";
-- Console output log file
file con_file: TEXT open write_mode is "hw_sim_console_log.txt";
-- Info record needed by the logging fuctions
signal log_info : t_log_info;
begin
---- UUT instantiation ---------------------------------------------------------
uut: entity work.light52_mcu
generic map (
IMPLEMENT_BCD_INSTRUCTIONS => BCD,
CODE_ROM_SIZE => work.obj_code_pkg.XCODE_SIZE,
XDATA_RAM_SIZE => work.obj_code_pkg.XDATA_SIZE,
OBJ_CODE => work.obj_code_pkg.object_code
)
port map (
clk => clk,
reset => reset,
txd => txd,
rxd => rxd,
external_irq => external_irq,
p0_out => p0_out,
p1_out => p1_out,
p2_in => p2_in,
p3_in => p3_in
);
-- UART is looped back in the test bench.
rxd <= txd;
-- I/O ports are looped back and otherwise unused.
p2_in <= p0_out;
p3_in <= p1_out;
-- External IRQ inputs are tied to port P1 for test purposes
external_irq <= p1_out;
---- Master clock: free running clock used as main module clock ------------
run_master_clock: process(done, clk)
begin
if done = '0' then
clk <= not clk after T/2;
end if;
end process run_master_clock;
---- Main simulation process: reset MCU and wait for fixed period ----------
drive_uut: process
begin
-- Leave reset asserted for a few clock cycles...
reset <= '1';
wait for T*4;
reset <= '0';
-- ...and wait for the test to hit a termination condition (evaluated by
-- function log_cpu_activity) or to just timeout.
wait for T*SIMULATION_LENGTH;
-- If we arrive here, the simulation timed out (termination conditions
-- trigger a failed assertion).
-- So print a timeout message and quit.
print("TB timed out.");
done <= '1';
wait;
end process drive_uut;
-- Logging process: launch logger functions --------------------------------
log_execution: process
begin
-- Log cpu activity until done='1'.
log_cpu_activity(clk, reset, done, "/uut",
log_info, work.obj_code_pkg.XCODE_SIZE, "log_info",
X"0000", log_file, con_file);
-- Flush console log file when finished.
log_flush_console(log_info, con_file);
wait;
end process log_execution;
end architecture testbench;
diff --git a/autotests/src/katedocument_test.cpp b/autotests/src/katedocument_test.cpp
index dd7eb535..f98254da 100644
--- a/autotests/src/katedocument_test.cpp
+++ b/autotests/src/katedocument_test.cpp
@@ -1,462 +1,462 @@
/* This file is part of the KDE libraries
Copyright (C) 2010 Dominik Haumann
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "katedocument_test.h"
#include "moc_katedocument_test.cpp"
#include
#include
#include
#include
#include
#include
#include
#include
///TODO: is there a FindValgrind cmake command we could use to
/// define this automatically?
// comment this out and run the test case with:
// valgrind --tool=callgrind --instr-atstart=no ./katedocument_test testSetTextPerformance
// or similar
//
// #define USE_VALGRIND
#ifdef USE_VALGRIND
#include
#endif
using namespace KTextEditor;
QTEST_MAIN(KateDocumentTest)
class MovingRangeInvalidator : public QObject
{
Q_OBJECT
public:
explicit MovingRangeInvalidator(QObject *parent = nullptr)
: QObject(parent)
{
}
void addRange(MovingRange *range)
{
m_ranges << range;
}
QList ranges() const
{
return m_ranges;
}
public Q_SLOTS:
void aboutToInvalidateMovingInterfaceContent()
{
qDeleteAll(m_ranges);
m_ranges.clear();
}
private:
QList m_ranges;
};
KateDocumentTest::KateDocumentTest()
: QObject()
{
}
KateDocumentTest::~KateDocumentTest()
{
}
void KateDocumentTest::initTestCase()
{
KTextEditor::EditorPrivate::enableUnitTestMode();
}
// tests:
// KTextEditor::DocumentPrivate::insertText with word wrap enabled. It is checked whether the
// text is correctly wrapped and whether the moving cursors maintain the correct
// position.
// see also: http://bugs.kde.org/show_bug.cgi?id=168534
void KateDocumentTest::testWordWrap()
{
KTextEditor::DocumentPrivate doc(false, false);
doc.setWordWrap(true);
doc.setWordWrapAt(80);
const QString content = QLatin1String(".........1.........2.........3.........4.........5.........6 ........7 ........8");
// space after 7 is now kept
// else we kill indentation...
const QString firstWrap = QLatin1String(".........1.........2.........3.........4.........5.........6 ........7 \n....x....8");
// space after 6 is now kept
// else we kill indentation...
const QString secondWrap = QLatin1String(".........1.........2.........3.........4.........5.........6 \n....ooooooooooo....7 ....x....8");
doc.setText(content);
MovingCursor *c = doc.newMovingCursor(Cursor(0, 75), MovingCursor::MoveOnInsert);
QCOMPARE(doc.text(), content);
QCOMPARE(c->toCursor(), Cursor(0, 75));
// type a character at (0, 75)
doc.insertText(c->toCursor(), QLatin1String("x"));
QCOMPARE(doc.text(), firstWrap);
QCOMPARE(c->toCursor(), Cursor(1, 5));
// set cursor to (0, 65) and type "ooooooooooo"
c->setPosition(Cursor(0, 65));
doc.insertText(c->toCursor(), QLatin1String("ooooooooooo"));
QCOMPARE(doc.text(), secondWrap);
QCOMPARE(c->toCursor(), Cursor(1, 15));
}
void KateDocumentTest::testReplaceQStringList()
{
KTextEditor::DocumentPrivate doc(false, false);
doc.setWordWrap(false);
doc.setText(QLatin1String("asdf\n"
"foo\n"
"foo\n"
"bar\n"));
- doc.replaceText(Range(1, 0, 3, 0), QStringList() << "new" << "text" << "", false);
+ doc.replaceText(Range(1, 0, 3, 0), { "new", "text", "" }, false);
QCOMPARE(doc.text(), QLatin1String("asdf\n"
"new\n"
"text\n"
"bar\n"));
}
void KateDocumentTest::testMovingInterfaceSignals()
{
KTextEditor::DocumentPrivate *doc = new KTextEditor::DocumentPrivate;
QSignalSpy aboutToDeleteSpy(doc, SIGNAL(aboutToDeleteMovingInterfaceContent(KTextEditor::Document*)));
QSignalSpy aboutToInvalidateSpy(doc, SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document*)));
QCOMPARE(doc->revision(), qint64(0));
QCOMPARE(aboutToInvalidateSpy.count(), 0);
QCOMPARE(aboutToDeleteSpy.count(), 0);
QTemporaryFile f;
f.open();
doc->openUrl(QUrl::fromLocalFile(f.fileName()));
QCOMPARE(doc->revision(), qint64(0));
//TODO: gets emitted once in closeFile and once in openFile - is that OK?
QCOMPARE(aboutToInvalidateSpy.count(), 2);
QCOMPARE(aboutToDeleteSpy.count(), 0);
doc->documentReload();
QCOMPARE(doc->revision(), qint64(0));
QCOMPARE(aboutToInvalidateSpy.count(), 4);
//TODO: gets emitted once in closeFile and once in openFile - is that OK?
QCOMPARE(aboutToDeleteSpy.count(), 0);
delete doc;
QCOMPARE(aboutToInvalidateSpy.count(), 4);
QCOMPARE(aboutToDeleteSpy.count(), 1);
}
void KateDocumentTest::testSetTextPerformance()
{
const int lines = 150;
const int columns = 80;
const int rangeLength = 4;
const int rangeGap = 1;
Q_ASSERT(columns % (rangeLength + rangeGap) == 0);
KTextEditor::DocumentPrivate doc;
MovingRangeInvalidator invalidator;
connect(&doc, SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document*)),
&invalidator, SLOT(aboutToInvalidateMovingInterfaceContent()));
QString text;
QVector ranges;
ranges.reserve(lines * columns / (rangeLength + rangeGap));
const QString line = QString().fill('a', columns);
for (int l = 0; l < lines; ++l) {
text.append(line);
text.append('\n');
for (int c = 0; c < columns; c += rangeLength + rangeGap) {
ranges << Range(l, c, l, c + rangeLength);
}
}
// replace
QBENCHMARK {
// init
doc.setText(text);
foreach (const Range &range, ranges)
{
invalidator.addRange(doc.newMovingRange(range));
}
QCOMPARE(invalidator.ranges().size(), ranges.size());
#ifdef USE_VALGRIND
CALLGRIND_START_INSTRUMENTATION
#endif
doc.setText(text);
#ifdef USE_VALGRIND
CALLGRIND_STOP_INSTRUMENTATION
#endif
QCOMPARE(doc.text(), text);
QVERIFY(invalidator.ranges().isEmpty());
}
}
void KateDocumentTest::testRemoveTextPerformance()
{
const int lines = 5000;
const int columns = 80;
KTextEditor::DocumentPrivate doc;
QString text;
const QString line = QString().fill('a', columns);
for (int l = 0; l < lines; ++l) {
text.append(line);
text.append('\n');
}
doc.setText(text);
// replace
QBENCHMARK_ONCE {
#ifdef USE_VALGRIND
CALLGRIND_START_INSTRUMENTATION
#endif
doc.editStart();
doc.removeText(doc.documentRange());
doc.editEnd();
#ifdef USE_VALGRIND
CALLGRIND_STOP_INSTRUMENTATION
#endif
}
}
void KateDocumentTest::testForgivingApiUsage()
{
KTextEditor::DocumentPrivate doc;
QVERIFY(doc.isEmpty());
QVERIFY(doc.replaceText(Range(0, 0, 100, 100), "asdf"));
QCOMPARE(doc.text(), QString("asdf"));
QCOMPARE(doc.lines(), 1);
QVERIFY(doc.replaceText(Range(2, 5, 2, 100), "asdf"));
QCOMPARE(doc.lines(), 3);
QCOMPARE(doc.text(), QLatin1String("asdf\n\n asdf"));
QVERIFY(doc.removeText(Range(0, 0, 1000, 1000)));
QVERIFY(doc.removeText(Range(0, 0, 0, 100)));
QVERIFY(doc.isEmpty());
doc.insertText(Cursor(100, 0), "foobar");
QCOMPARE(doc.line(100), QString("foobar"));
doc.setText("nY\nnYY\n");
QVERIFY(doc.removeText(Range(0, 0, 0, 1000)));
}
void KateDocumentTest::testReplaceTabs()
{
KTextEditor::DocumentPrivate doc;
auto view = static_cast(doc.createView(nullptr));
auto reset = [&]() {
doc.setText(" Hi!");
view->setCursorPosition(Cursor(0, 0));
};
doc.setHighlightingMode ("C++");
doc.config()->setTabWidth(4);
doc.config()->setIndentationMode("cppstyle");
// no replace tabs, no indent pasted text
doc.setConfigValue("replace-tabs", false);
doc.setConfigValue("indent-pasted-text", false);
reset();
doc.insertText(Cursor(0, 0), "\t");
QCOMPARE(doc.text(), QStringLiteral("\t Hi!"));
reset();
doc.typeChars(view, "\t");
QCOMPARE(doc.text(), QStringLiteral("\t Hi!"));
reset();
doc.paste(view, "some\ncode\n 3\nhi\n");
QCOMPARE(doc.text(), QStringLiteral("some\ncode\n 3\nhi\n Hi!"));
// now, enable replace tabs
doc.setConfigValue("replace-tabs", true);
reset();
doc.insertText(Cursor(0, 0), "\t");
// calling insertText does not replace tabs
QCOMPARE(doc.text(), QStringLiteral("\t Hi!"));
reset();
doc.typeChars(view, "\t");
// typing text replaces tabs
QCOMPARE(doc.text(), QStringLiteral(" Hi!"));
reset();
doc.paste(view, "\t");
// pasting text does not with indent-pasted off
QCOMPARE(doc.text(), QStringLiteral("\t Hi!"));
doc.setConfigValue("indent-pasted-text", true);
doc.setText("int main() {\n \n}");
view->setCursorPosition(Cursor(1, 4));
doc.paste(view, "\tHi");
// ... and it still does not with indent-pasted on.
// This behaviour is up to discussion.
QCOMPARE(doc.text(), QStringLiteral("int main() {\n Hi\n}"));
reset();
doc.paste(view, "some\ncode\n 3\nhi");
QCOMPARE(doc.text(), QStringLiteral("some\ncode\n3\nhi Hi!"));
}
/**
* Provides slots to check data sent in specific signals. Slot names are derived from corresponding test names.
*/
class SignalHandler : public QObject
{
Q_OBJECT
public Q_SLOTS:
void slotMultipleLinesRemoved(KTextEditor::Document *, const KTextEditor::Range &, const QString &oldText)
{
QCOMPARE(oldText, QString("line2\nline3\n"));
}
void slotNewlineInserted(KTextEditor::Document *, const KTextEditor::Range &range)
{
QCOMPARE(range, Range(Cursor(1, 4), Cursor(2, 0)));
}
};
void KateDocumentTest::testRemoveMultipleLines()
{
KTextEditor::DocumentPrivate doc;
doc.setText("line1\n"
"line2\n"
"line3\n"
"line4\n");
SignalHandler handler;
connect(&doc, &KTextEditor::DocumentPrivate::textRemoved, &handler, &SignalHandler::slotMultipleLinesRemoved);
doc.removeText(Range(1, 0, 3, 0));
}
void KateDocumentTest::testInsertNewline()
{
KTextEditor::DocumentPrivate doc;
doc.setText("this is line\n"
"this is line2\n");
SignalHandler handler;
connect(&doc, SIGNAL(textInserted(KTextEditor::Document*,KTextEditor::Range)), &handler, SLOT(slotNewlineInserted(KTextEditor::Document*,KTextEditor::Range)));
doc.editWrapLine(1, 4);
}
void KateDocumentTest::testInsertAfterEOF()
{
KTextEditor::DocumentPrivate doc;
doc.setText("line0\n"
"line1");
const QString input = QLatin1String("line3\n"
"line4");
const QString expected = QLatin1String("line0\n"
"line1\n"
"\n"
"line3\n"
"line4");
doc.insertText(KTextEditor::Cursor(3, 0), input);
QCOMPARE(doc.text(), expected);
}
// we have two different ways of creating the checksum:
// in KateFileLoader and KTextEditor::DocumentPrivate::createDigest. Make
// sure, these two implementations result in the same checksum.
void KateDocumentTest::testDigest()
{
// Git hash of test file (git hash-object data/md5checksum.txt):
const QByteArray gitHash = "696e6d35a5d9cc28d16e56bdcb2d2a88126b814e";
// QCryptographicHash is used, therefore we need fromHex here
const QByteArray fileDigest = QByteArray::fromHex(gitHash);
// make sure, Kate::TextBuffer and KTextEditor::DocumentPrivate::createDigest() equal
KTextEditor::DocumentPrivate doc;
doc.openUrl(QUrl::fromLocalFile(QLatin1String(TEST_DATA_DIR"md5checksum.txt")));
const QByteArray bufferDigest(doc.checksum());
QVERIFY(doc.createDigest());
const QByteArray docDigest(doc.checksum());
QCOMPARE(bufferDigest, fileDigest);
QCOMPARE(docDigest, fileDigest);
}
void KateDocumentTest::testDefStyleNum()
{
KTextEditor::DocumentPrivate doc;
doc.setText("foo\nbar\nasdf");
QCOMPARE(doc.defStyleNum(0, 0), 0);
}
void KateDocumentTest::testTypeCharsWithSurrogateAndNewLine()
{
KTextEditor::DocumentPrivate doc;
auto view = static_cast(doc.createView(nullptr));
const uint surrogateUcs4String[] = { 0x1f346, '\n', 0x1f346, 0 };
const auto surrogateString = QString::fromUcs4(surrogateUcs4String);
doc.typeChars(view, surrogateString);
QCOMPARE(doc.text(), surrogateString);
}
void KateDocumentTest::testRemoveComposedCharacters()
{
KTextEditor::DocumentPrivate doc;
auto view = static_cast(doc.createView(nullptr));
doc.setText(QString::fromUtf8("व्यक्तियों"));
doc.del(view, Cursor(0, 0));
QCOMPARE(doc.text(), QString::fromUtf8(("क्तियों")));
doc.backspace(view, Cursor(0, 7));
QCOMPARE(doc.text(), QString::fromUtf8(("क्ति")));
}
#include "katedocument_test.moc"
diff --git a/autotests/src/kateencodingtest.cpp b/autotests/src/kateencodingtest.cpp
index 06d7c4f5..84a86946 100644
--- a/autotests/src/kateencodingtest.cpp
+++ b/autotests/src/kateencodingtest.cpp
@@ -1,64 +1,63 @@
/* This file is part of the Kate project.
*
* Copyright (C) 2010 Christoph Cullmann
* Copyright (C) 2010 Dominik Haumann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include
#include "katetextbuffer.h"
#include
-#include
int main(int argc, char *argv[])
{
// construct core app
QCoreApplication app(argc, argv);
// test mode
KTextEditor::EditorPrivate::enableUnitTestMode();
// get arguments
QString encoding = app.arguments().at(1);
QString inFile = app.arguments().at(2);
QString outFile = app.arguments().at(3);
Kate::TextBuffer buffer(nullptr);
// set codec
buffer.setFallbackTextCodec(QTextCodec::codecForName("ISO 8859-15"));
buffer.setTextCodec(QTextCodec::codecForName(encoding.toLatin1()));
// switch to Mac EOL, this will test eol detection, as files are normal unix or dos
buffer.setEndOfLineMode(Kate::TextBuffer::eolMac);
// load file
bool encodingErrors = false;
bool tooLongLines = false;
int longestLineLoaded;
if (!buffer.load(inFile, encodingErrors, tooLongLines, longestLineLoaded, false) || encodingErrors) {
return 1;
}
// save file
if (!buffer.save(outFile)) {
return 1;
}
return 0;
}
diff --git a/autotests/src/kateview_test.cpp b/autotests/src/kateview_test.cpp
index aab724e9..b34a2211 100644
--- a/autotests/src/kateview_test.cpp
+++ b/autotests/src/kateview_test.cpp
@@ -1,404 +1,395 @@
/* This file is part of the KDE libraries
Copyright (C) 2010 Milian Wolff
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "kateview_test.h"
#include "moc_kateview_test.cpp"
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace KTextEditor;
QTEST_MAIN(KateViewTest)
KateViewTest::KateViewTest()
: QObject()
{
KTextEditor::EditorPrivate::enableUnitTestMode();
}
KateViewTest::~KateViewTest()
{
}
void KateViewTest::testCoordinatesToCursor()
{
KTextEditor::DocumentPrivate doc(false, false);
doc.setText("Hi World!\nHi\n");
KTextEditor::View* view1 = static_cast(doc.createView(nullptr));
view1->show();
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(0, 2))),
KTextEditor::Cursor(0, 2));
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(1, 1))),
KTextEditor::Cursor(1, 1));
// behind end of line should give an invalid cursor
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(1, 5))),
KTextEditor::Cursor::invalid());
QCOMPARE(view1->cursorToCoordinate(KTextEditor::Cursor(3, 1)), QPoint(-1, -1));
// check consistency between cursorToCoordinate(view->cursorPosition() and cursorPositionCoordinates()
// random position
view1->setCursorPosition(KTextEditor::Cursor(0, 3));
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(view1->cursorPosition())),
KTextEditor::Cursor(0, 3));
QCOMPARE(view1->coordinatesToCursor(view1->cursorPositionCoordinates()), KTextEditor::Cursor(0, 3));
// end of line
view1->setCursorPosition(KTextEditor::Cursor(0, 9));
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(0, 9))),
KTextEditor::Cursor(0, 9));
QCOMPARE(view1->coordinatesToCursor(view1->cursorPositionCoordinates()), KTextEditor::Cursor(0, 9));
// empty line
view1->setCursorPosition(KTextEditor::Cursor(2, 0));
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(2, 0))),
KTextEditor::Cursor(2, 0));
QCOMPARE(view1->coordinatesToCursor(view1->cursorPositionCoordinates()), KTextEditor::Cursor(2, 0));
// same test again, but with message widget on top visible
KTextEditor::Message *message = new KTextEditor::Message("Jo World!", KTextEditor::Message::Information);
doc.postMessage(message);
// wait 500ms until show animation is finished, so the message widget is visible
QTest::qWait(500);
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(0, 2))),
KTextEditor::Cursor(0, 2));
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(1, 1))),
KTextEditor::Cursor(1, 1));
// behind end of line should give an invalid cursor
QCOMPARE(view1->coordinatesToCursor(view1->cursorToCoordinate(KTextEditor::Cursor(1, 5))),
KTextEditor::Cursor::invalid());
QCOMPARE(view1->cursorToCoordinate(KTextEditor::Cursor(3, 1)), QPoint(-1, -1));
}
void KateViewTest::testCursorToCoordinates()
{
KTextEditor::DocumentPrivate doc(false, false);
doc.setText("int a;");
KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
view->config()->setDynWordWrap(true);
view->show();
// don't crash, see https://bugs.kde.org/show_bug.cgi?id=337863
view->cursorToCoordinate(Cursor(0, 0));
view->cursorToCoordinate(Cursor(1, 0));
view->cursorToCoordinate(Cursor(-1, 0));
}
void KateViewTest::testReloadMultipleViews()
{
QTemporaryFile file("XXXXXX.cpp");
file.open();
QTextStream stream(&file);
const QString line = "const char* foo = \"asdf\"\n";
for (int i = 0; i < 200; ++i) {
stream << line;
}
stream << flush;
file.close();
KTextEditor::DocumentPrivate doc;
QVERIFY(doc.openUrl(QUrl::fromLocalFile(file.fileName())));
QCOMPARE(doc.highlightingMode(), QString("C++"));
KTextEditor::ViewPrivate *view1 = new KTextEditor::ViewPrivate(&doc, nullptr);
KTextEditor::ViewPrivate *view2 = new KTextEditor::ViewPrivate(&doc, nullptr);
view1->show();
view2->show();
QCOMPARE(doc.views().count(), 2);
QVERIFY(doc.documentReload());
}
void KateViewTest::testTabCursorOnReload()
{
// testcase for https://bugs.kde.org/show_bug.cgi?id=258480
QTemporaryFile file("XXXXXX.cpp");
file.open();
QTextStream stream(&file);
stream << "\tfoo\n";
file.close();
KTextEditor::DocumentPrivate doc;
QVERIFY(doc.openUrl(QUrl::fromLocalFile(file.fileName())));
KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
const KTextEditor::Cursor cursor(0, 4);
view->setCursorPosition(cursor);
QCOMPARE(view->cursorPosition(), cursor);
QVERIFY(doc.documentReload());
QCOMPARE(view->cursorPosition(), cursor);
}
void KateViewTest::testLowerCaseBlockSelection()
{
// testcase for https://bugs.kde.org/show_bug.cgi?id=258480
KTextEditor::DocumentPrivate doc;
doc.setText("nY\nnYY\n");
KTextEditor::ViewPrivate *view1 = new KTextEditor::ViewPrivate(&doc, nullptr);
view1->setBlockSelection(true);
view1->setSelection(Range(0, 1, 1, 3));
view1->lowercase();
QCOMPARE(doc.text(), QString("ny\nnyy\n"));
}
void KateViewTest::testSelection()
{
// see also: https://bugs.kde.org/show_bug.cgi?id=277422
// wrong behavior before:
// Open file with text
// click at end of some line (A) and drag to right, i.e. without selecting anything
// click somewhere else (B)
// shift click to another place (C)
// => expected: selection from B to C
// => actual: selection from A to C
QTemporaryFile file("XXXXXX.txt");
file.open();
QTextStream stream(&file);
stream << "A\n"
<< "B\n"
<< "C";
stream << flush;
file.close();
KTextEditor::DocumentPrivate doc;
QVERIFY(doc.openUrl(QUrl::fromLocalFile(file.fileName())));
KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
view->resize(100, 200);
view->show();
QObject *internalView = nullptr;
foreach (QObject* child, view->children()) {
if (child->metaObject()->className() == QByteArrayLiteral("KateViewInternal")) {
internalView = child;
break;
}
}
QVERIFY(internalView);
const QPoint afterA = view->cursorToCoordinate(Cursor(0, 1));
const QPoint afterB = view->cursorToCoordinate(Cursor(1, 1));
const QPoint afterC = view->cursorToCoordinate(Cursor(2, 1));
// click after A
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonPress, afterA,
Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier));
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonRelease, afterA,
Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier));
QCOMPARE(view->cursorPosition(), Cursor(0, 1));
// drag to right
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonPress, afterA,
Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier));
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseMove, afterA + QPoint(50, 0),
Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier));
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonRelease, afterA + QPoint(50, 0),
Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier));
QCOMPARE(view->cursorPosition(), Cursor(0, 1));
QVERIFY(!view->selection());
// click after C
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonPress, afterC,
Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier));
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonRelease, afterC,
Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier));
QCOMPARE(view->cursorPosition(), Cursor(2, 1));
// shift+click after B
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonPress, afterB,
Qt::LeftButton, Qt::LeftButton,
Qt::ShiftModifier));
QCoreApplication::sendEvent(internalView, new QMouseEvent(QEvent::MouseButtonRelease, afterB,
Qt::LeftButton, Qt::LeftButton,
Qt::ShiftModifier));
QCOMPARE(view->cursorPosition(), Cursor(1, 1));
QCOMPARE(view->selectionRange(), Range(1, 1, 2, 1));
}
void KateViewTest::testKillline()
{
KTextEditor::DocumentPrivate doc;
- doc.insertLines(0, QStringList()
- << "foo"
- << "bar"
- << "baz"
- );
+ doc.insertLines(0, { "foo", "bar", "baz" });
KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
view->setCursorPositionInternal(KTextEditor::Cursor(1, 2));
view->killLine();
QCOMPARE(doc.text(), QLatin1String("foo\nbaz\n"));
doc.clear();
QVERIFY(doc.isEmpty());
- doc.insertLines(0, QStringList()
- << "foo"
- << "bar"
- << "baz"
- << "xxx"
- );
+ doc.insertLines(0, { "foo", "bar", "baz", "xxx" });
view->setCursorPositionInternal(KTextEditor::Cursor(1, 2));
view->shiftDown();
view->killLine();
QCOMPARE(doc.text(), QLatin1String("foo\nxxx\n"));
}
void KateViewTest::testFoldFirstLine()
{
QTemporaryFile file("XXXXXX.cpp");
file.open();
QTextStream stream(&file);
stream << "/**\n"
<< " * foo\n"
<< " */\n"
<< "\n"
<< "int main() {}\n";
file.close();
KTextEditor::DocumentPrivate doc;
QVERIFY(doc.openUrl(QUrl::fromLocalFile(file.fileName())));
QCOMPARE(doc.highlightingMode(), QString("C++"));
KTextEditor::ViewPrivate *view = new KTextEditor::ViewPrivate(&doc, nullptr);
view->config()->setFoldFirstLine(false);
view->setCursorPosition({4, 0});
// initially, nothing is folded
QVERIFY(view->textFolding().isLineVisible(1));
// now change the config, and expect the header to be folded
view->config()->setFoldFirstLine(true);
qint64 foldedRangeId = 0;
QVERIFY(!view->textFolding().isLineVisible(1, &foldedRangeId));
// now unfold the range
QVERIFY(view->textFolding().unfoldRange(foldedRangeId));
QVERIFY(view->textFolding().isLineVisible(1));
// and save the file, we do not expect the folding to change then
doc.setModified(true);
doc.saveFile();
QVERIFY(view->textFolding().isLineVisible(1));
// now reload the document, nothing should change
doc.setModified(false);
QVERIFY(doc.documentReload());
QVERIFY(view->textFolding().isLineVisible(1));
}
// test for bug https://bugs.kde.org/374163
void KateViewTest::testDragAndDrop()
{
KTextEditor::DocumentPrivate doc(false, false);
doc.setText("line0\n"
"line1\n"
"line2\n"
"\n"
"line4");
KTextEditor::View* view = static_cast(doc.createView(nullptr));
view->show();
view->resize(400, 300);
QWidget *internalView = nullptr;
foreach (QObject* child, view->children()) {
if (child->metaObject()->className() == QByteArrayLiteral("KateViewInternal")) {
internalView = qobject_cast(child);
break;
}
}
QVERIFY(internalView);
// select "line1\n"
view->setSelection(Range(1, 0, 2, 0));
QCOMPARE(view->selectionRange(), Range(1, 0, 2, 0));
- QTest::qWaitForWindowExposed(view);
+ QVERIFY(QTest::qWaitForWindowExposed(view));
const QPoint startDragPos = internalView->mapFrom(view, view->cursorToCoordinate(KTextEditor::Cursor(1, 2)));
const QPoint endDragPos = internalView->mapFrom(view, view->cursorToCoordinate(KTextEditor::Cursor(3, 0)));
const QPoint gStartDragPos = internalView->mapToGlobal(startDragPos);
const QPoint gEndDragPos = internalView->mapToGlobal(endDragPos);
// now drag and drop selected text to Cursor(3, 0)
QMouseEvent pressEvent(QEvent::MouseButtonPress, startDragPos, gStartDragPos,
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QCoreApplication::sendEvent(internalView, &pressEvent);
// ugly workaround: Drag & Drop has own blocking event queue. Therefore, we need a single-shot timer to
// break out of the blocking event queue, see (*)
QTimer::singleShot(50, [&](){
QMouseEvent moveEvent(QEvent::MouseMove, endDragPos + QPoint(5, 0), gEndDragPos + QPoint(5, 0),
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QMouseEvent releaseEvent(QEvent::MouseButtonRelease, endDragPos, gEndDragPos,
Qt::LeftButton, Qt::NoButton, Qt::NoModifier);
QCoreApplication::sendEvent(internalView, &moveEvent);
QCoreApplication::sendEvent(internalView, &releaseEvent);
});
// (*) this somehow blocks...
QMouseEvent moveEvent1(QEvent::MouseMove, endDragPos + QPoint(10, 0), gEndDragPos + QPoint(10, 0),
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QCoreApplication::sendEvent(internalView, &moveEvent1);
QTest::qWait(100);
// final tests of dragged text
QCOMPARE(doc.text(), QString("line0\n"
"line2\n"
"line1\n"
"\n"
"line4"));
QCOMPARE(view->cursorPosition(), KTextEditor::Cursor(3, 0));
QCOMPARE(view->selectionRange(), Range(2, 0, 3, 0));
}
// kate: indent-mode cstyle; indent-width 4; replace-tabs on;
diff --git a/autotests/src/scripting_test.cpp b/autotests/src/scripting_test.cpp
index 63da86a7..f54c1fd6 100644
--- a/autotests/src/scripting_test.cpp
+++ b/autotests/src/scripting_test.cpp
@@ -1,75 +1,74 @@
/**
* This file is part of the KDE project
*
* Copyright (C) 2013 Gerald Senarclens de Grancy
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
//BEGIN Includes
#include "scripting_test.h"
#include "kateview.h"
#include "katedocument.h"
#include "kateconfig.h"
#include "katecmd.h"
#include "kateglobal.h"
#include
#include
#include
#include
#include
#include
#include
#include
-#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "script_test_base.h"
#include "testutils.h"
QTEST_MAIN(ScriptingTest)
#define FAILURE( test, comment ) qMakePair( (test), (comment) )
void ScriptingTest::initTestCase()
{
ScriptTestBase::initTestCase();
m_section = "scripting";
m_script_dir = "";
}
void ScriptingTest::bugs_data()
{
getTestData("bugs");
}
void ScriptingTest::bugs()
{
runTest(ExpectedFailures());
}
diff --git a/autotests/src/vimode/completion.cpp b/autotests/src/vimode/completion.cpp
index 216b553f..30471ecc 100644
--- a/autotests/src/vimode/completion.cpp
+++ b/autotests/src/vimode/completion.cpp
@@ -1,610 +1,610 @@
/*
* This file is part of the KDE libraries
*
* Copyright (C) 2014 Miquel Sabaté Solà
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include
#include
#include
#include
#include
#include "completion.h"
#include "fakecodecompletiontestmodel.h"
#include "vimode/mappings.h"
#include "vimode/globalstate.h"
using namespace KTextEditor;
using KateVi::Mappings;
QTEST_MAIN(CompletionTest)
//BEGIN: VimCodeCompletionTestModel
VimCodeCompletionTestModel::VimCodeCompletionTestModel(KTextEditor::View *parent)
: KTextEditor::CodeCompletionModel(parent)
{
setRowCount(3);
cc()->setAutomaticInvocationEnabled(true);
// It would add additional items and we don't want that in tests
cc()->unregisterCompletionModel(KTextEditor::EditorPrivate::self()->wordCompletionModel());
cc()->registerCompletionModel(this);
}
QVariant VimCodeCompletionTestModel::data(const QModelIndex &index, int role) const
{
// Order is important, here, as the completion widget seems to do its own sorting.
const char *completions[] = { "completion1", "completion2", "completion3" };
if (role == Qt::DisplayRole) {
if (index.column() == Name) {
return QString(completions[index.row()]);
}
}
return QVariant();
}
CodeCompletionInterface * VimCodeCompletionTestModel::cc() const
{
return dynamic_cast(const_cast(QObject::parent()));
}
//END: VimCodeCompletionTestModel
//BEGIN: CodeCompletionInterface
FailTestOnInvocationModel::FailTestOnInvocationModel(KTextEditor::View *parent)
: KTextEditor::CodeCompletionModel(parent)
{
setRowCount(3);
cc()->setAutomaticInvocationEnabled(true);
// It would add additional items and we don't want that in tests.
cc()->unregisterCompletionModel(EditorPrivate::self()->wordCompletionModel());
cc()->registerCompletionModel(this);
}
QVariant FailTestOnInvocationModel::data(const QModelIndex &index, int role) const
{
Q_UNUSED(index);
Q_UNUSED(role);
failTest();
return QVariant();
}
void FailTestOnInvocationModel::failTest() const
{
QFAIL("Shouldn't be invoking me!");
}
CodeCompletionInterface * FailTestOnInvocationModel::cc() const
{
return dynamic_cast(const_cast(QObject::parent()));
}
//END: CodeCompletionInterface
//BEGIN: CompletionTest
void CompletionTest::FakeCodeCompletionTests()
{
// Test that FakeCodeCompletionTestModel behaves similar to the code-completion in e.g. KDevelop.
const bool oldStealKeys = KateViewConfig::global()->viInputModeStealKeys();
KateViewConfig::global()->setViInputModeStealKeys(true); // For Ctrl-P, Ctrl-N etc
ensureKateViewVisible(); // KTextEditor::ViewPrivate needs to be visible for the completion widget.
FakeCodeCompletionTestModel *fakeCodeCompletionModel = new FakeCodeCompletionTestModel(kate_view);
kate_view->registerCompletionModel(fakeCodeCompletionModel);
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
DoTest("", "i\\ctrl-p\\enter", "completionC");
DoTest("", "i\\ctrl-p\\ctrl-p\\enter", "completionB");
DoTest("", "i\\ctrl-p\\ctrl-p\\ctrl-p\\enter", "completionA");
DoTest("", "i\\ctrl-p\\ctrl-p\\ctrl-p\\ctrl-p\\enter", "completionC");
// If no word before cursor, don't delete any text.
BeginTest("");
clearTrackedDocumentChanges();
TestPressKey("i\\ctrl- \\enter");
QCOMPARE(m_docChanges.length(), 1);
FinishTest("completionA");
// Apparently, we must delete the word before the cursor upon completion
// (even if we replace it with identical text!)
BeginTest("compl");
TestPressKey("ea");
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 0), Cursor(0, 5)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 0), Cursor(0, 11)));
QCOMPARE(m_docChanges[1].newText(), QString("completionA"));
FinishTest("completionA");
// A "word" is currently alphanumeric, plus underscore.
- fakeCodeCompletionModel->setCompletions(QStringList() << "w_123completion");
+ fakeCodeCompletionModel->setCompletions({ "w_123completion" });
BeginTest("(w_123");
TestPressKey("ea");
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 1), Cursor(0, 6)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 1), Cursor(0, 16)));
QCOMPARE(m_docChanges[1].newText(), QString("w_123completion"));
FinishTest("(w_123completion");
// "Removing tail on complete" is apparently done in three stages:
// delete word up to the cursor; insert new word; then delete remainder.
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
BeginTest("(w_123comp");
TestPressKey("6li");
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 3);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 1), Cursor(0, 6)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 1), Cursor(0, 16)));
QCOMPARE(m_docChanges[1].newText(), QString("w_123completion"));
QCOMPARE(m_docChanges[2].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[2].changeRange(), Range(Cursor(0, 16), Cursor(0, 20)));
FinishTest("(w_123completion");
// If we don't remove tail, just delete up to the cursor and insert.
fakeCodeCompletionModel->setRemoveTailOnComplete(false);
BeginTest("(w_123comp");
TestPressKey("6li");
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 1), Cursor(0, 6)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 1), Cursor(0, 16)));
QCOMPARE(m_docChanges[1].newText(), QString("w_123completion"));
FinishTest("(w_123completioncomp");
// If no opening bracket after the cursor, a function taking no arguments
// is added as "function()", and the cursor placed after the closing ")".
// The addition of "function()" is done in two steps: first "function", then "()".
BeginTest("object->");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall()");
+ fakeCodeCompletionModel->setCompletions({ "functionCall()" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("$a\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[0].newText(), QString("functionCall"));
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 20), Cursor(0, 22)));
QCOMPARE(m_docChanges[1].newText(), QString("()"));
TestPressKey("X");
FinishTest("object->functionCall()X");
// If no opening bracket after the cursor, a function taking at least one argument
// is added as "function()", and the cursor placed after the opening "(".
// The addition of "function()" is done in two steps: first "function", then "()".
qDebug() << "Fleep";
BeginTest("object->");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...)");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...)" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("$a\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[0].newText(), QString("functionCall"));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 20), Cursor(0, 22)));
QCOMPARE(m_docChanges[1].newText(), QString("()"));
TestPressKey("X");
FinishTest("object->functionCall(X)");
// If there is an opening bracket after the cursor, we merge the function call
// with that.
// Even if the function takes no arguments, we still place the cursor after the opening bracket,
// in contrast to the case where there is no opening bracket after the cursor.
// No brackets are added. No removals occur if there is no word before the cursor.
BeginTest("object->(");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall()");
+ fakeCodeCompletionModel->setCompletions({ "functionCall()" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("f(i\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 1);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[0].newText(), QString("functionCall"));
TestPressKey("X");
FinishTest("object->functionCall(X");
// There can't be any non-whitespace between cursor position and opening bracket, though!
BeginTest("object->|( (");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall()");
+ fakeCodeCompletionModel->setCompletions({ "functionCall()" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("f>a\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[0].newText(), QString("functionCall"));
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 20), Cursor(0, 22)));
QCOMPARE(m_docChanges[1].newText(), QString("()"));
TestPressKey("X");
FinishTest("object->functionCall()X|( (");
// Whitespace before the bracket is fine, though.
BeginTest("object-> (<-Cursor here!");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall()");
+ fakeCodeCompletionModel->setCompletions({ "functionCall()" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("f>a\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 1);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[0].newText(), QString("functionCall"));
TestPressKey("X");
FinishTest("object->functionCall (X<-Cursor here!");
// Be careful with positioning the cursor if we delete leading text!
BeginTest("object-> (<-Cursor here!");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall()");
+ fakeCodeCompletionModel->setCompletions({ "functionCall()" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("f>afunct");
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 13)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[1].newText(), QString("functionCall"));
TestPressKey("X");
FinishTest("object->functionCall (X<-Cursor here!");
// If we're removing tail on complete, it's whether there is a suitable opening
// bracket *after* the word (not the cursor) that's important.
BeginTest("object->function (<-Cursor here!");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall()");
+ fakeCodeCompletionModel->setCompletions({ "functionCall()" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("12li"); // Start inserting before the "t" in "function"
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 3);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 12)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[1].newText(), QString("functionCall"));
QCOMPARE(m_docChanges[2].changeType(), DocChange::TextRemoved);
qDebug() << "m_docChanges[2].changeRange(): " << m_docChanges[2].changeRange();
QCOMPARE(m_docChanges[2].changeRange(), Range(Cursor(0, 20), Cursor(0, 24)));
TestPressKey("X");
FinishTest("object->functionCall (X<-Cursor here!");
// Repeat of bracket-merging stuff, this time for functions that take at least one argument.
BeginTest("object->(");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...)");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...)" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("f(i\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 1);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextInserted);
qDebug() << "Range: " << m_docChanges[0].changeRange();
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[0].newText(), QString("functionCall"));
TestPressKey("X");
FinishTest("object->functionCall(X");
// There can't be any non-whitespace between cursor position and opening bracket, though!
BeginTest("object->|( (");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...)");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...)" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("f>a\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[0].newText(), QString("functionCall"));
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 20), Cursor(0, 22)));
QCOMPARE(m_docChanges[1].newText(), QString("()"));
TestPressKey("X");
FinishTest("object->functionCall(X)|( (");
// Whitespace before the bracket is fine, though.
BeginTest("object-> (<-Cursor here!");
qDebug() << "NooooO";
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...)");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...)" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("f>a\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 1);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[0].newText(), QString("functionCall"));
TestPressKey("X");
FinishTest("object->functionCall (X<-Cursor here!");
// Be careful with positioning the cursor if we delete leading text!
BeginTest("object-> (<-Cursor here!");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...)");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...)" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("f>afunct");
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 2);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 13)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[1].newText(), QString("functionCall"));
TestPressKey("X");
FinishTest("object->functionCall (X<-Cursor here!");
// If we're removing tail on complete, it's whether there is a suitable opening
// bracket *after* the word (not the cursor) that's important.
BeginTest("object->function (<-Cursor here!");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...)");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...)" });
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
clearTrackedDocumentChanges();
TestPressKey("12li"); // Start inserting before the "t" in "function"
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 3);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 8), Cursor(0, 12)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 8), Cursor(0, 20)));
QCOMPARE(m_docChanges[1].newText(), QString("functionCall"));
QCOMPARE(m_docChanges[2].changeType(), DocChange::TextRemoved);
qDebug() << "m_docChanges[2].changeRange(): " << m_docChanges[2].changeRange();
QCOMPARE(m_docChanges[2].changeRange(), Range(Cursor(0, 20), Cursor(0, 24)));
TestPressKey("X");
FinishTest("object->functionCall (X<-Cursor here!");
// Deal with function completions which add a ";".
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall();");
+ fakeCodeCompletionModel->setCompletions({ "functionCall();" });
clearTrackedDocumentChanges();
TestPressKey("ifun");
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 3);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 0), Cursor(0, 3)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 0), Cursor(0, 12)));
QCOMPARE(m_docChanges[1].newText(), QString("functionCall"));
QCOMPARE(m_docChanges[2].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[2].changeRange(), Range(Cursor(0, 12), Cursor(0, 15)));
QCOMPARE(m_docChanges[2].newText(), QString("();"));
FinishTest("functionCall();");
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall();");
+ fakeCodeCompletionModel->setCompletions({ "functionCall();" });
TestPressKey("ifun\\ctrl- \\enterX");
FinishTest("functionCall();X");
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...);");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...);" });
clearTrackedDocumentChanges();
TestPressKey("ifun");
clearTrackedDocumentChanges();
TestPressKey("\\ctrl- \\enter");
QCOMPARE(m_docChanges.size(), 3);
QCOMPARE(m_docChanges[0].changeType(), DocChange::TextRemoved);
QCOMPARE(m_docChanges[0].changeRange(), Range(Cursor(0, 0), Cursor(0, 3)));
QCOMPARE(m_docChanges[1].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[1].changeRange(), Range(Cursor(0, 0), Cursor(0, 12)));
QCOMPARE(m_docChanges[1].newText(), QString("functionCall"));
QCOMPARE(m_docChanges[2].changeType(), DocChange::TextInserted);
QCOMPARE(m_docChanges[2].changeRange(), Range(Cursor(0, 12), Cursor(0, 15)));
QCOMPARE(m_docChanges[2].newText(), QString("();"));
FinishTest("functionCall();");
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...);");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...);" });
TestPressKey("ifun\\ctrl- \\enterX");
FinishTest("functionCall(X);");
// Completions ending with ";" do not participate in bracket merging.
BeginTest("(<-old bracket");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall();");
+ fakeCodeCompletionModel->setCompletions({ "functionCall();" });
TestPressKey("ifun\\ctrl- \\enterX");
FinishTest("functionCall();X(<-old bracket");
BeginTest("(<-old bracket");
- fakeCodeCompletionModel->setCompletions(QStringList() << "functionCall(...);");
+ fakeCodeCompletionModel->setCompletions({ "functionCall(...);" });
TestPressKey("ifun\\ctrl- \\enterX");
FinishTest("functionCall(X);(<-old bracket");
KateViewConfig::global()->setViInputModeStealKeys(oldStealKeys);
kate_view->hide();
mainWindow->hide();
kate_view->unregisterCompletionModel(fakeCodeCompletionModel);
delete fakeCodeCompletionModel;
}
void CompletionTest::CompletionTests()
{
const bool oldRemoveTailOnCompletion = KateViewConfig::global()->wordCompletionRemoveTail();
// For these tests, assume we don't swallow the tail on completion.
KateViewConfig::global()->setWordCompletionRemoveTail(false);
KateViewConfig::global()->setViInputModeStealKeys(true); // For Ctrl-P, Ctrl-N etc
ensureKateViewVisible(); // KTextEditor::ViewPrivate needs to be visible for the completion widget.
VimCodeCompletionTestModel *testModel = new VimCodeCompletionTestModel(kate_view);
BeginTest("");
TestPressKey("i\\ctrl-p");
waitForCompletionWidgetToActivate();
TestPressKey("\\return");
FinishTest("completion3");
BeginTest("");
TestPressKey("i\\ctrl- ");
waitForCompletionWidgetToActivate();
TestPressKey("\\return");
FinishTest("completion1");
BeginTest("");
TestPressKey("i\\ctrl-n");
waitForCompletionWidgetToActivate();
TestPressKey("\\return");
FinishTest("completion1");
// Test wraps around from top to bottom.
BeginTest("");
TestPressKey("i\\ctrl- \\ctrl-p");
waitForCompletionWidgetToActivate();
TestPressKey("\\return");
FinishTest("completion3");
// Test wraps around from bottom to top.
BeginTest("");
TestPressKey("i\\ctrl- \\ctrl-n\\ctrl-n\\ctrl-n");
waitForCompletionWidgetToActivate();
TestPressKey("\\return");
FinishTest("completion1");
// Test does not re-invoke completion when doing a "." repeat.
BeginTest("");
TestPressKey("i\\ctrl- ");
waitForCompletionWidgetToActivate();
TestPressKey("\\return\\ctrl-c");
kate_view->unregisterCompletionModel(testModel);
FailTestOnInvocationModel *failsTestOnInvocation = new FailTestOnInvocationModel(kate_view);
TestPressKey("gg.");
FinishTest("completion1completion1");
kate_view->unregisterCompletionModel(failsTestOnInvocation);
kate_view->registerCompletionModel(testModel);
// Test that the full completion is repeated when repeat an insert that uses completion,
// where the completion list was not manually invoked.
BeginTest("");
TestPressKey("i");
// Simulate "automatic" invoking of completion.
kate_view->completionWidget()->userInvokedCompletion();
waitForCompletionWidgetToActivate();
TestPressKey("\\return\\ctrl-cgg.");
FinishTest("completion1completion1");
clearAllMappings();
// Make sure the "Enter"/ "Return" used when invoking completions is not swallowed before being
// passed to the key mapper.
kate_view->registerCompletionModel(testModel);
vi_global->mappings()->add(Mappings::InsertModeMapping, "cb", "mapped-shouldntbehere", Mappings::Recursive);
BeginTest("");
TestPressKey("ic");
kate_view->userInvokedCompletion();
waitForCompletionWidgetToActivate();
QVERIFY(kate_view->completionWidget()->isCompletionActive());
TestPressKey("\\enterb");
FinishTest("completion1b");
BeginTest("");
TestPressKey("ic");
kate_view->userInvokedCompletion();
waitForCompletionWidgetToActivate();
QVERIFY(kate_view->completionWidget()->isCompletionActive());
TestPressKey("\\returnb");
FinishTest("completion1b");
// Make sure the completion widget is dismissed on ESC, ctrl-c and ctrl-[.
BeginTest("");
TestPressKey("ic");
kate_view->userInvokedCompletion();
waitForCompletionWidgetToActivate();
QVERIFY(kate_view->completionWidget()->isCompletionActive());
TestPressKey("\\esc");
QVERIFY(!kate_view->completionWidget()->isCompletionActive());
FinishTest("c");
BeginTest("");
TestPressKey("ic");
kate_view->userInvokedCompletion();
waitForCompletionWidgetToActivate();
QVERIFY(kate_view->completionWidget()->isCompletionActive());
TestPressKey("\\ctrl-c");
QVERIFY(!kate_view->completionWidget()->isCompletionActive());
FinishTest("c");
BeginTest("");
TestPressKey("ic");
kate_view->userInvokedCompletion();
waitForCompletionWidgetToActivate();
QVERIFY(kate_view->completionWidget()->isCompletionActive());
TestPressKey("\\ctrl-[");
QVERIFY(!kate_view->completionWidget()->isCompletionActive());
FinishTest("c");
kate_view->unregisterCompletionModel(testModel);
// Check that the repeat-last-change handles Completions in the same way as Macros do
// i.e. fairly intelligently :)
FakeCodeCompletionTestModel *fakeCodeCompletionModel = new FakeCodeCompletionTestModel(kate_view);
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
kate_view->registerCompletionModel(fakeCodeCompletionModel);
clearAllMacros();
BeginTest("funct\nnoa\ncomtail\ncomtail");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "functionwithargs(...)" << "noargfunction()");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "functionwithargs(...)", "noargfunction()" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
// Record 'a'.
TestPressKey("i\\right\\right\\right\\right\\right\\ctrl- \\enterfirstArg"); // Function with args.
TestPressKey("\\home\\down\\right\\right\\right\\ctrl- \\enter"); // Function no args.
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
TestPressKey("\\home\\down\\right\\right\\right\\ctrl- \\enter"); // Cut off tail.
fakeCodeCompletionModel->setRemoveTailOnComplete(false);
KateViewConfig::global()->setWordCompletionRemoveTail(false);
TestPressKey("\\home\\down\\right\\right\\right\\ctrl- \\enter\\ctrl-c"); // Don't cut off tail.
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
// Replay.
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("funct\nnoa\ncomtail\ncomtail");
TestPressKey("gg.");
FinishTest("functionwithargs(firstArg)\nnoargfunction()\ncompletionA\ncompletionAtail");
// Clear our log of completions for each change.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA");
+ fakeCodeCompletionModel->setCompletions({ "completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("ciw\\ctrl- \\enter\\ctrl-c");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionB");
+ fakeCodeCompletionModel->setCompletions({ "completionB" });
TestPressKey("ciw\\ctrl- \\enter\\ctrl-c");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey(".");
FinishTest("completionB");
kate_view->unregisterCompletionModel(fakeCodeCompletionModel);
delete fakeCodeCompletionModel;
KateViewConfig::global()->setWordCompletionRemoveTail(oldRemoveTailOnCompletion);
// Hide the kate_view for subsequent tests.
kate_view->hide();
mainWindow->hide();
}
void CompletionTest::waitForCompletionWidgetToActivate()
{
BaseTest::waitForCompletionWidgetToActivate(kate_view);
}
void CompletionTest::clearTrackedDocumentChanges()
{
m_docChanges.clear();
}
//END: CompletionTest
diff --git a/autotests/src/vimode/keys.cpp b/autotests/src/vimode/keys.cpp
index 3c232618..251f944a 100644
--- a/autotests/src/vimode/keys.cpp
+++ b/autotests/src/vimode/keys.cpp
@@ -1,1581 +1,1581 @@
/*
* This file is part of the KDE libraries
*
* Copyright (C) 2014 Miquel Sabaté Solà
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include
#include
#include
#include
#include
#include
#include "keys.h"
#include "emulatedcommandbarsetupandteardown.h"
#include "fakecodecompletiontestmodel.h"
#include "vimode/mappings.h"
#include "vimode/globalstate.h"
using namespace KTextEditor;
using KateVi::Mappings;
using KateVi::KeyParser;
QTEST_MAIN(KeysTest)
//BEGIN: KeysTest
void KeysTest::MappingTests()
{
// QVERIFY(false);
const int mappingTimeoutMSOverride = QString::fromLocal8Bit(qgetenv("KATE_VIMODE_TEST_MAPPINGTIMEOUTMS")).toInt();
const int mappingTimeoutMS = (mappingTimeoutMSOverride > 0) ? mappingTimeoutMSOverride : 2000;
KateViewConfig::global()->setViInputModeStealKeys(true); // For tests involving e.g.
{
// Check storage and retrieval of mapping recursion.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "ihello", Mappings::Recursive);
QVERIFY(vi_global->mappings()->isRecursive(Mappings::NormalModeMapping, "'"));
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "ihello", Mappings::NonRecursive);
QVERIFY(!vi_global->mappings()->isRecursive(Mappings::NormalModeMapping, "a"));
}
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "ihello^aworld", Mappings::Recursive);
DoTest("", "'", "hworldello");
// Ensure that the non-mapping logged keypresses are cleared before we execute a mapping
vi_global->mappings()->add(Mappings::NormalModeMapping, "'a", "rO", Mappings::Recursive);
DoTest("X", "'a", "O");
{
// Check that '123 is mapped after the timeout, given that we also have mappings that
// extend it (e.g. '1234, '12345, etc) and which it itself extends ('1, '12, etc).
clearAllMappings();
BeginTest("");
vi_input_mode_manager->keyMapper()->setMappingTimeout(mappingTimeoutMS);;
QString consectiveDigits;
for (int i = 1; i < 9; i++) {
consectiveDigits += QString::number(i);
vi_global->mappings()->add(Mappings::NormalModeMapping, "'" + consectiveDigits, "iMapped from " + consectiveDigits + "", Mappings::Recursive);
}
TestPressKey("'123");
QCOMPARE(kate_document->text(), QString("")); // Shouldn't add anything until after the timeout!
QTest::qWait(2 * mappingTimeoutMS);
FinishTest("Mapped from 123");
}
// Mappings are not "counted": any count entered applies to the first command/ motion in the mapped sequence,
// and is not used to replay the entire mapped sequence times in a row.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'downmapping", "j", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "'testmapping", "ifooibar", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "'testmotionmapping", "lj", Mappings::Recursive);
DoTest("AAAA\nXXXX\nXXXX\nXXXX\nXXXX\nBBBB\nCCCC\nDDDD", "jd3'downmapping", "AAAA\nBBBB\nCCCC\nDDDD");
DoTest("", "5'testmapping", "foofoofoofoofobaro");
DoTest("XXXX\nXXXX\nXXXX\nXXXX", "3'testmotionmappingrO", "XXXX\nXXXO\nXXXX\nXXXX");
// Regression test for a weird mistake I made: *completely* remove all counting for the
// first command in the sequence; don't just set it to 1! If it is set to 1, then "%"
// will mean "go to position 1 percent of the way through the document" rather than
// go to matching item.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "gl", "%", Mappings::Recursive);
DoTest("0\n1\n2\n3\n4\n5\nfoo bar(xyz) baz", "jjjjjjwdgl", "0\n1\n2\n3\n4\n5\nfoo baz");
// Test that countable mappings work even when triggered by timeouts.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'testmapping", "ljrO", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "'testmappingdummy", "dummy", Mappings::Recursive);
BeginTest("XXXX\nXXXX\nXXXX\nXXXX");
vi_input_mode_manager->keyMapper()->setMappingTimeout(mappingTimeoutMS);;
TestPressKey("3'testmapping");
QTest::qWait(2 * mappingTimeoutMS);
FinishTest("XXXX\nXXXO\nXXXX\nXXXX");
// Test that telescoping mappings don't interfere with built-in commands. Assumes that gp
// is implemented and working.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "gdummy", "idummy", Mappings::Recursive);
DoTest("hello", "yiwgpx", "hhellollo");
// Test that we can map a sequence of keys that extends a built-in command and use
// that sequence without the built-in command firing.
// Once again, assumes that gp is implemented and working.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "gpa", "idummy", Mappings::Recursive);
DoTest("hello", "yiwgpa", "dummyhello");
// Test that we can map a sequence of keys that extends a built-in command and still
// have the original built-in command fire if we timeout after entering that command.
// Once again, assumes that gp is implemented and working.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "gpa", "idummy", Mappings::Recursive);
BeginTest("hello");
vi_input_mode_manager->keyMapper()->setMappingTimeout(mappingTimeoutMS);;
TestPressKey("yiwgp");
QTest::qWait(2 * mappingTimeoutMS);
TestPressKey("x");
FinishTest("hhellollo");
// Test that something that starts off as a partial mapping following a command
// (the "g" in the first "dg" is a partial mapping of "gj"), when extended to something
// that is definitely not a mapping ("gg"), results in the full command being executed ("dgg").
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "gj", "aj", Mappings::Recursive);
DoTest("foo\nbar\nxyz", "jjdgg", "");
// Make sure that a mapped sequence of commands is merged into a single undo-able edit.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'a", "ofooofooofoo", Mappings::Recursive);
DoTest("bar", "'au", "bar");
// Make sure that a counted mapping is merged into a single undoable edit.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'a", "ofoo", Mappings::Recursive);
DoTest("bar", "5'au", "bar");
// Some test setup for non-recursive mapping g -> gj (cf: bug:314415)
// Firstly: work out the expected result of gj (this might be fragile as default settings
// change, etc.). We use BeginTest & FinishTest for the setup and teardown etc, but this is
// not an actual test - it's just computing the expected result of the real test!
const QString multiVirtualLineText = "foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo";
ensureKateViewVisible(); // Needs to be visible in order for virtual lines to make sense.
KateViewConfig::global()->setDynWordWrap(true);
BeginTest(multiVirtualLineText);
TestPressKey("gjrX");
const QString expectedAfterVirtualLineDownAndChange = kate_document->text();
Q_ASSERT_X(expectedAfterVirtualLineDownAndChange.contains("X") && !expectedAfterVirtualLineDownAndChange.startsWith('X'), "setting up j->gj testcase data", "gj doesn't seem to have worked correctly!");
FinishTest(expectedAfterVirtualLineDownAndChange);
// Test that non-recursive mappings are not expanded.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "j", "gj", Mappings::NonRecursive);
DoTest(multiVirtualLineText, "jrX", expectedAfterVirtualLineDownAndChange);
KateViewConfig::global()->setDynWordWrap(false);
// Test that recursive mappings are expanded.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "X", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "X", "rx", Mappings::Recursive);
DoTest("foo", "la", "fxo");
// Test that the flag that stops mappings being expanded is reset after the mapping has been executed.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "j", "gj", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "X", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "X", "rx", Mappings::Recursive);
DoTest("foo", "jla", "fxo");
// Even if we start with a recursive mapping, as soon as we hit one that is not recursive, we should stop
// expanding.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "X", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "X", "r.", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "i", "a", Mappings::Recursive);
DoTest("foo", "li", "oo");
// Regression test: Using a mapping may trigger a call to updateSelection(), which can change the mode
// from VisualLineMode to plain VisualMode.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "gA", "%", Mappings::NonRecursive);
DoTest("xyz\nfoo\n{\nbar\n}", "jVjgAdgglP", "foo\n{\nbar\n}\nxyz");
// Piggy back on the previous test with a regression test for issue where, if gA is mapped to %, vgly
// will yank one more character than it should.
DoTest("foo(bar)X", "vgAyp", "ffoo(bar)oo(bar)X");
// Make sure that a successful mapping does not break the "if we select stuff externally in Normal mode,
// we should switch to Visual Mode" thing.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "gA", "%", Mappings::NonRecursive);
BeginTest("foo bar xyz()");
TestPressKey("gAr.");
kate_view->setSelection(Range(0, 1, 0, 4)); // Actually selects "oo " (i.e. without the "b").
TestPressKey("d");
FinishTest("fbar xyz(.");
// Regression tests for BUG:260655
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "f", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "d", "i", Mappings::NonRecursive);
DoTest("foo dar", "adr.", "foo .ar");
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "F", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "d", "i", Mappings::NonRecursive);
DoTest("foo dar", "$adr.", "foo .ar");
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "t", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "d", "i", Mappings::NonRecursive);
DoTest("foo dar", "adr.", "foo.dar");
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "T", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "d", "i", Mappings::NonRecursive);
DoTest("foo dar", "$adr.", "foo d.r");
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "r", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "d", "i", Mappings::NonRecursive);
DoTest("foo dar", "ad", "doo dar");
// Feel free to map the keypress after that, though.
DoTest("foo dar", "addber\\esc", "berdoo dar");
// Also, be careful about how we interpret "waiting for find char/ replace char"
DoTest("foo dar", "ffas", "soo dar");
// Ignore raw "Ctrl", "Shift", "Meta" and "Alt" keys, which will almost certainly end up being pressed as
// we try to trigger mappings that contain these keys.
clearAllMappings();
{
// Ctrl.
vi_global->mappings()->add(Mappings::NormalModeMapping, "", "ictrl", Mappings::NonRecursive);
BeginTest("");
QKeyEvent *ctrlKeyDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), ctrlKeyDown);
QApplication::sendPostedEvents();
TestPressKey("\\ctrl-a");
ctrlKeyDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), ctrlKeyDown);
QApplication::sendPostedEvents();
TestPressKey("\\ctrl-b");
FinishTest("ctrl");
}
{
// Shift.
vi_global->mappings()->add(Mappings::NormalModeMapping, "C", "ishift", Mappings::NonRecursive);
BeginTest("");
QKeyEvent *ctrlKeyDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), ctrlKeyDown);
QApplication::sendPostedEvents();
TestPressKey("\\ctrl-a");
QKeyEvent *shiftKeyDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Shift, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), shiftKeyDown);
QApplication::sendPostedEvents();
TestPressKey("C");
FinishTest("shift");
}
{
// Alt.
vi_global->mappings()->add(Mappings::NormalModeMapping, "", "ialt", Mappings::NonRecursive);
BeginTest("");
QKeyEvent *ctrlKeyDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), ctrlKeyDown);
QApplication::sendPostedEvents();
TestPressKey("\\ctrl-a");
QKeyEvent *altKeyDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Alt, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), altKeyDown);
QApplication::sendPostedEvents();
TestPressKey("\\alt-b");
FinishTest("alt");
}
{
// Meta.
vi_global->mappings()->add(Mappings::NormalModeMapping, "", "imeta", Mappings::NonRecursive);
BeginTest("");
QKeyEvent *ctrlKeyDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Control, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), ctrlKeyDown);
QApplication::sendPostedEvents();
TestPressKey("\\ctrl-a");
QKeyEvent *metaKeyDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Meta, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), metaKeyDown);
QApplication::sendPostedEvents();
TestPressKey("\\meta-b");
FinishTest("meta");
}
{
// Can have mappings in Visual mode, distinct from Normal mode..
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "a", "3l", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "inose", Mappings::NonRecursive);
DoTest("0123456", "lvad", "056");
// The recursion in Visual Mode is distinct from that of Normal mode.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "b", "", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::VisualModeMapping, "a", "b", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "b", Mappings::Recursive);
DoTest("XXX\nXXX", "lvajd", "XXX");
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "b", "", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::VisualModeMapping, "a", "b", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "b", Mappings::NonRecursive);
DoTest("XXX\nXXX", "lvajd", "XXX\nXXX");
// A Visual mode mapping applies to all Visual modes (line, block, etc).
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "a", "2j", Mappings::NonRecursive);
DoTest("123\n456\n789", "lvad", "19");
DoTest("123\n456\n789", "l\\ctrl-vad", "13\n46\n79");
DoTest("123\n456\n789", "lVad", "");
// Same for recursion.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "b", "2j", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::VisualModeMapping, "a", "b", Mappings::Recursive);
DoTest("123\n456\n789", "lvad", "19");
DoTest("123\n456\n789", "l\\ctrl-vad", "13\n46\n79");
DoTest("123\n456\n789", "lVad", "");
// Can clear Visual mode mappings.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "h", "l", Mappings::Recursive);
vi_global->mappings()->clear(Mappings::VisualModeMapping);
DoTest("123\n456\n789", "lvhd", "3\n456\n789");
DoTest("123\n456\n789", "l\\ctrl-vhd", "3\n456\n789");
DoTest("123\n456\n789", "lVhd", "456\n789");
vi_global->mappings()->add(Mappings::VisualModeMapping, "h", "l", Mappings::Recursive);
vi_global->mappings()->clear(Mappings::VisualModeMapping);
DoTest("123\n456\n789", "lvhd", "3\n456\n789");
DoTest("123\n456\n789", "l\\ctrl-vhd", "3\n456\n789");
DoTest("123\n456\n789", "lVhd", "456\n789");
vi_global->mappings()->add(Mappings::VisualModeMapping, "h", "l", Mappings::Recursive);
vi_global->mappings()->clear(Mappings::VisualModeMapping);
DoTest("123\n456\n789", "lvhd", "3\n456\n789");
DoTest("123\n456\n789", "l\\ctrl-vhd", "3\n456\n789");
DoTest("123\n456\n789", "lVhd", "456\n789");
}
{
// Can have mappings in Insert mode.
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "a", "xyz", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "inose", Mappings::NonRecursive);
DoTest("foo", "ia\\esc", "xyzfoo");
// Recursion for Insert mode.
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "b", "c", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::InsertModeMapping, "a", "b", Mappings::NonRecursive);
DoTest("", "ia\\esc", "b");
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "b", "c", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::InsertModeMapping, "a", "b", Mappings::Recursive);
DoTest("", "ia\\esc", "c");
clearAllMappings();
// Clear mappings for Insert mode.
vi_global->mappings()->add(Mappings::InsertModeMapping, "a", "b", Mappings::NonRecursive);
vi_global->mappings()->clear(Mappings::InsertModeMapping);
DoTest("", "ia\\esc", "a");
}
{
EmulatedCommandBarSetUpAndTearDown vimStyleCommandBarTestsSetUpAndTearDown(vi_input_mode, kate_view, mainWindow);
// Can have mappings in Emulated Command Bar.
clearAllMappings();
vi_global->mappings()->add(Mappings::CommandModeMapping, "a", "xyz", Mappings::NonRecursive);
DoTest(" a xyz", "/a\\enterrX", " a Xyz");
// Use mappings from Normal mode as soon as we exit command bar via Enter.
vi_global->mappings()->add(Mappings::NormalModeMapping, "a", "ixyz", Mappings::NonRecursive);
DoTest(" a xyz", "/a\\entera", " a xyzxyz");
// Multiple mappings.
vi_global->mappings()->add(Mappings::CommandModeMapping, "b", "123", Mappings::NonRecursive);
DoTest(" xyz123", "/ab\\enterrX", " Xyz123");
// Recursive mappings.
vi_global->mappings()->add(Mappings::CommandModeMapping, "b", "a", Mappings::Recursive);
DoTest(" xyz", "/b\\enterrX", " Xyz");
// Can clear all.
vi_global->mappings()->clear(Mappings::CommandModeMapping);
DoTest(" ab xyz xyz123", "/ab\\enterrX", " Xb xyz xyz123");
}
// Test that not *both* of the mapping and the mapped keys are logged for repetition via "."
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "ixyz", "iabc", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "gl", "%", Mappings::NonRecursive);
DoTest("", "ixyz\\esc.", "ababcc");
DoTest("foo()X\nbarxyz()Y", "cglbaz\\escggj.", "bazX\nbazY");
// Regression test for a crash when executing a mapping that switches to Normal mode.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "h", "d", Mappings::Recursive);
DoTest("foo", "vlh", "o");
{
// Test that we can set/ unset mappings from the command-line.
clearAllMappings();
DoTest("", "\\:nn foo ibar\\foo", "bar");
// "nn" is not recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "l", "iabc", Mappings::NonRecursive);
DoTest("xxx", "\\:nn foo l\\foorX", "xXx");
// "no" is not recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "l", "iabc", Mappings::NonRecursive);
DoTest("xxx", "\\:no foo l\\foorX", "xXx");
// "noremap" is not recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "l", "iabc", Mappings::NonRecursive);
DoTest("xxx", "\\:noremap foo l\\foorX", "xXx");
// "nm" is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "l", "iabc", Mappings::NonRecursive);
DoTest("xxx", "\\:nm foo l\\foorX", "abXxxx");
// "nmap" is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "l", "iabc", Mappings::NonRecursive);
DoTest("xxx", "\\:nmap foo l\\foorX", "abXxxx");
// Unfortunately, "map" is a reserved word :/
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "l", "iabc", Mappings::NonRecursive);
DoTest("xxx", "\\:map foo l\\foorX", "abXxxx", ShouldFail, "'map' is reserved for other stuff in Kate command line");
// nunmap works in normal mode.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "w", "ciwabc", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "b", "ciwxyz", Mappings::NonRecursive);
DoTest(" 123 456 789", "\\:nunmap b\\WWwbrX", " 123 Xbc 789");
// nmap and nunmap whose "from" is a complex encoded expression.
clearAllMappings();
BeginTest("123");
TestPressKey("\\:nmap ciwxyz\\");
TestPressKey("\\ctrl-9");
FinishTest("xyz");
BeginTest("123");
TestPressKey("\\:nunmap \\");
TestPressKey("\\ctrl-9");
FinishTest("123");
// vmap works in Visual mode and is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "l", "d", Mappings::NonRecursive);
DoTest("abco", "\\:vmap foo l\\v\\rightfoogU", "co");
// vmap does not work in Normal mode.
clearAllMappings();
DoTest("xxx", "\\:vmap foo l\\foorX", "xxx\nrX");
// vm works in Visual mode and is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "l", "d", Mappings::NonRecursive);
DoTest("abco", "\\:vm foo l\\v\\rightfoogU", "co");
// vn works in Visual mode and is not recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "l", "d", Mappings::NonRecursive);
DoTest("abco", "\\:vn foo l\\v\\rightfoogU", "ABCo");
// vnoremap works in Visual mode and is not recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "l", "d", Mappings::NonRecursive);
DoTest("abco", "\\:vnoremap foo l\\v\\rightfoogU", "ABCo");
// vunmap works in Visual Mode.
clearAllMappings();
vi_global->mappings()->add(Mappings::VisualModeMapping, "l", "w", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::VisualModeMapping, "gU", "2b", Mappings::NonRecursive);
DoTest("foo bar xyz", "\\:vunmap gU\\wvlgUd", "foo BAR Xyz");
// imap works in Insert mode and is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "l", "d", Mappings::NonRecursive);
DoTest("", "\\:imap foo l\\ifoo\\esc", "d");
// im works in Insert mode and is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "l", "d", Mappings::NonRecursive);
DoTest("", "\\:im foo l\\ifoo\\esc", "d");
// ino works in Insert mode and is not recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "l", "d", Mappings::NonRecursive);
DoTest("", "\\:ino foo l\\ifoo\\esc", "l");
// inoremap works in Insert mode and is not recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "l", "d", Mappings::NonRecursive);
DoTest("", "\\:inoremap foo l\\ifoo\\esc", "l");
// iunmap works in Insert mode.
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "l", "d", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::InsertModeMapping, "m", "e", Mappings::NonRecursive);
DoTest("", "\\:iunmap l\\ilm\\esc", "le");
{
EmulatedCommandBarSetUpAndTearDown vimStyleCommandBarTestsSetUpAndTearDown(vi_input_mode, kate_view, mainWindow);
// cmap works in emulated command bar and is recursive.
// NOTE: need to do the cmap call using the direct execution (i.e. \\:cmap blah blah\\), *not* using
// the emulated command bar (:cmap blah blah\\enter), as this will be subject to mappings, which
// can interfere with the tests!
clearAllMappings();
vi_global->mappings()->add(Mappings::CommandModeMapping, "l", "d", Mappings::NonRecursive);
DoTest(" l d foo", "\\:cmap foo l\\/foo\\enterrX", " l X foo");
// cm works in emulated command bar and is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::CommandModeMapping, "l", "d", Mappings::NonRecursive);
DoTest(" l d foo", "\\:cm foo l\\/foo\\enterrX", " l X foo");
// cnoremap works in emulated command bar and is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::CommandModeMapping, "l", "d", Mappings::NonRecursive);
DoTest(" l d foo", "\\:cnoremap foo l\\/foo\\enterrX", " X d foo");
// cno works in emulated command bar and is recursive.
clearAllMappings();
vi_global->mappings()->add(Mappings::CommandModeMapping, "l", "d", Mappings::NonRecursive);
DoTest(" l d foo", "\\:cno foo l\\/foo\\enterrX", " X d foo");
// cunmap works in emulated command bar.
clearAllMappings();
vi_global->mappings()->add(Mappings::CommandModeMapping, "l", "d", Mappings::NonRecursive);
vi_global->mappings()->add(Mappings::CommandModeMapping, "m", "e", Mappings::NonRecursive);
DoTest(" de le", "\\:cunmap l\\/lm\\enterrX", " de Xe");
}
// Can use to signify a space.
clearAllMappings();
DoTest("", "\\:nn h iab\\h ", " a b");
}
// More recursion tests - don't lose characters from a Recursive mapping if it looks like they might
// be part of a different mapping (but end up not being so).
// (Here, the leading "i" in "irecursive" could be part of the mapping "ihello").
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "ihello", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "ihello", "irecursive", Mappings::Recursive);
DoTest("", "'", "recursive");
// Capslock in insert mode is not handled by Vim nor by KateViewInternal, and ends up
// being sent to KateViInputModeManager::handleKeypress twice (it could be argued that this is
// incorrect behaviour on the part of KateViewInternal), which can cause infinite
// recursion if we are not careful about identifying replayed rejected keypresses.
BeginTest("foo bar");
TestPressKey("i");
QKeyEvent *capslockKeyPress = new QKeyEvent(QEvent::KeyPress, Qt::Key_CapsLock, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), capslockKeyPress);
QApplication::sendPostedEvents();
FinishTest("foo bar");
// Mapping the u and the U commands to other keys.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "t", "u", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "r", "U", Mappings::Recursive);
DoTest("", "ihello\\esct", "");
DoTest("", "ihello\\esctr", "hello");
//
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "l", "", Mappings::Recursive);
DoTest("Hello", "lrr", "rello");
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "l", "", Mappings::Recursive);
DoTest("Hello", "sl\\esc", "ello");
clearAllMappings();
vi_global->mappings()->add(Mappings::InsertModeMapping, "l", "abc", Mappings::Recursive);
DoTest("Hello", "sl\\esc", "abcello");
// Clear mappings for subsequent tests.
clearAllMappings();
}
void KeysTest::LeaderTests()
{
// Clean slate.
KateViewConfig::global()->setViInputModeStealKeys(true);
clearAllMappings();
// By default the backslash character is the leader. The default leader
// is picked from the config. If we don't want to mess this from other
// tests, it's better if we mock the config.
const QString viTestKConfigFileName = QStringLiteral("vimodetest-leader-katevimoderc");
KConfig viTestKConfig(viTestKConfigFileName);
vi_global->mappings()->setLeader(QChar());
vi_global->readConfig(&viTestKConfig);
vi_global->mappings()->add(Mappings::NormalModeMapping, "i", "ii", Mappings::Recursive);
DoTest("", "\\\\i", "i");
// We can change the leader and it will work.
clearAllMappings();
vi_global->readConfig(&viTestKConfig);
vi_global->mappings()->setLeader(QChar::fromLatin1(','));
vi_global->mappings()->add(Mappings::NormalModeMapping, "i", "ii", Mappings::Recursive);
DoTest("", ",i", "i");
// Mixing up the with its value.
clearAllMappings();
vi_global->readConfig(&viTestKConfig);
vi_global->mappings()->setLeader(QChar::fromLatin1(','));
vi_global->mappings()->add(Mappings::NormalModeMapping, ",", "ii", Mappings::Recursive);
DoTest("", ",,", "i");
vi_global->mappings()->add(Mappings::NormalModeMapping, ",", "ii", Mappings::Recursive);
DoTest("", ",,", "i");
// It doesn't work outside normal mode.
clearAllMappings();
vi_global->readConfig(&viTestKConfig);
vi_global->mappings()->setLeader(QChar::fromLatin1(','));
vi_global->mappings()->add(Mappings::InsertModeMapping, "i", "ii", Mappings::Recursive);
DoTest("", "i,ii", ",ii");
// Clear mappings for subsequent tests.
clearAllMappings();
}
void KeysTest::ParsingTests()
{
// BUG #298726
const QChar char_o_diaeresis(246);
// Test that we can correctly translate finnish key ö
QKeyEvent *k = new QKeyEvent(QEvent::KeyPress, 214, Qt::NoModifier, 47, 246, 16400, char_o_diaeresis);
QCOMPARE(KeyParser::self()->KeyEventToQChar(*k), QChar(246));
// Test that it can be used in mappings
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, char_o_diaeresis, "ifoo", Mappings::Recursive);
DoTest("hello", QString("ll%1bar").arg(char_o_diaeresis), "hefoobarllo");
// Test that is parsed like
QCOMPARE(KeyParser::self()->vi2qt("cr"), int(Qt::Key_Enter));
const QString &enter = KeyParser::self()->encodeKeySequence(QLatin1String(""));
QCOMPARE(KeyParser::self()->decodeKeySequence(enter), QLatin1String(""));
}
void KeysTest::AltGr()
{
QKeyEvent *altGrDown;
QKeyEvent *altGrUp;
// Test Alt-gr still works - this isn't quite how things work in "real-life": in real-life, something like
// Alt-gr+7 would be a "{", but I don't think this can be reproduced without sending raw X11
// keypresses to Qt, so just duplicate the keypress events we would receive if we pressed
// Alt-gr+7 (that is: Alt-gr down; "{"; Alt-gr up).
BeginTest("");
TestPressKey("i");
altGrDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_AltGr, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), altGrDown);
QApplication::sendPostedEvents();
// Not really Alt-gr and 7, but this is the key event that is reported by Qt if we press that.
QKeyEvent *altGrAnd7 = new QKeyEvent(QEvent::KeyPress, Qt::Key_BraceLeft, Qt::GroupSwitchModifier, "{");
QApplication::postEvent(kate_view->focusProxy(), altGrAnd7);
QApplication::sendPostedEvents();
altGrUp = new QKeyEvent(QEvent::KeyRelease, Qt::Key_AltGr, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), altGrUp);
QApplication::sendPostedEvents();
TestPressKey("\\ctrl-c");
FinishTest("{");
// French Bepo keyabord AltGr + Shift + s = Ù = Unicode(0x00D9);
const QString ugrave = QString(QChar(0x00D9));
BeginTest("");
TestPressKey("i");
altGrDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_AltGr, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), altGrDown);
QApplication::sendPostedEvents();
altGrDown = new QKeyEvent(QEvent::KeyPress, Qt::Key_Shift, Qt::ShiftModifier | Qt::GroupSwitchModifier);
QApplication::postEvent(kate_view->focusProxy(), altGrDown);
QApplication::sendPostedEvents();
QKeyEvent *altGrAndUGrave = new QKeyEvent(QEvent::KeyPress, Qt::Key_Ugrave, Qt::ShiftModifier | Qt::GroupSwitchModifier, ugrave);
qDebug() << QString("%1").arg(altGrAndUGrave->modifiers(), 10, 16);
QApplication::postEvent(kate_view->focusProxy(), altGrAndUGrave);
QApplication::sendPostedEvents();
altGrUp = new QKeyEvent(QEvent::KeyRelease, Qt::Key_AltGr, Qt::NoModifier);
QApplication::postEvent(kate_view->focusProxy(), altGrUp);
QApplication::sendPostedEvents();
FinishTest(ugrave);
}
void KeysTest::MacroTests()
{
// Update the status on qa.
const QString macroIsRecordingStatus = QLatin1String("(") + i18n("recording") + QLatin1String(")");
clearAllMacros();
BeginTest("");
QVERIFY(!kate_view->viewModeHuman().contains(macroIsRecordingStatus));
TestPressKey("qa");
QVERIFY(kate_view->viewModeHuman().contains(macroIsRecordingStatus));
TestPressKey("q");
QVERIFY(!kate_view->viewModeHuman().contains(macroIsRecordingStatus));
FinishTest("");
// The closing "q" is not treated as the beginning of a new "begin recording macro" command.
clearAllMacros();
BeginTest("foo");
TestPressKey("qaqa");
QVERIFY(!kate_view->viewModeHuman().contains(macroIsRecordingStatus));
TestPressKey("xyz\\esc");
FinishTest("fxyzoo");
// Record and playback a single keypress into macro register "a".
clearAllMacros();
DoTest("foo bar", "qawqgg@arX", "foo Xar");
// Two macros - make sure the old one is cleared.
clearAllMacros();
DoTest("123 foo bar xyz", "qawqqabqggww@arX", "123 Xoo bar xyz");
// Update the status on qb.
clearAllMacros();
BeginTest("");
QVERIFY(!kate_view->viewModeHuman().contains(macroIsRecordingStatus));
TestPressKey("qb");
QVERIFY(kate_view->viewModeHuman().contains(macroIsRecordingStatus));
TestPressKey("q");
QVERIFY(!kate_view->viewModeHuman().contains(macroIsRecordingStatus));
FinishTest("");
// Record and playback a single keypress into macro register "b".
clearAllMacros();
DoTest("foo bar", "qbwqgg@brX", "foo Xar");
// More complex macros.
clearAllMacros();
DoTest("foo", "qcrXql@c", "XXo");
// Re-recording a macro should only clear that macro.
clearAllMacros();
DoTest("foo 123", "qaraqqbrbqqbrBqw@a", "Boo a23");
// Empty macro clears it.
clearAllMacros();
DoTest("", "qaixyz\\ctrl-cqqaq@a", "xyz");
// Hold two macros in memory simultanenously so both can be played.
clearAllMacros();
DoTest("foo 123", "qaraqqbrbqw@al@b", "boo ab3");
// Do more complex things, including switching modes and using ctrl codes.
clearAllMacros();
DoTest("foo bar", "qainose\\ctrl-c~qw@a", "nosEfoo nosEbar");
clearAllMacros();
DoTest("foo bar", "qayiwinose\\ctrl-r0\\ctrl-c~qw@a", "nosefoOfoo nosebaRbar");
clearAllMacros();
DoTest("foo bar", "qavldqw@a", "o r");
// Make sure we can use "q" in insert mode while recording a macro.
clearAllMacros();
DoTest("foo bar", "qaiqueequeg\\ctrl-cqw@a", "queequegfoo queequegbar");
// Can invoke a macro in Visual Mode.
clearAllMacros();
DoTest("foo bar", "qa~qvlll@a", "FOO Bar");
// Invoking a macro in Visual Mode does not exit Visual Mode.
clearAllMacros();
DoTest("foo bar", "qallqggv@a~", "FOO bar");;
// Can record & macros in Visual Mode for playback in Normal Mode.
clearAllMacros();
DoTest("foo bar", "vqblq\\ctrl-c@b~", "foO bar");
// Recording a macro in Visual Mode does not exit Visual Mode.
clearAllMacros();
DoTest("foo bar", "vqblql~", "FOO bar");
// Recognize correctly numbered registers
clearAllMacros();
DoTest("foo", "q1iX\\escq@1", "XXfoo");
{
// Ensure that we can call emulated command bar searches, and that we don't record
// synthetic keypresses.
EmulatedCommandBarSetUpAndTearDown vimStyleCommandBarTestsSetUpAndTearDown(vi_input_mode, kate_view, mainWindow);
clearAllMacros();
DoTest("foo bar\nblank line", "qa/bar\\enterqgg@arX", "foo Xar\nblank line");
// More complex searching stuff.
clearAllMacros();
DoTest("foo 123foo123\nbar 123bar123", "qayiw/\\ctrl-r0\\enterrXqggj@a", "foo 123Xoo123\nbar 123Xar123");
}
// Expand mappings, but don't do *both* original keypresses and executed keypresses.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "ihello", Mappings::Recursive);
clearAllMacros();
DoTest("", "qa'q@a", "hellhelloo");
// Actually, just do the mapped keypresses, not the executed mappings (like Vim).
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "ihello", Mappings::Recursive);
clearAllMacros();
BeginTest("");
TestPressKey("qa'q");
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "igoodbye", Mappings::Recursive);
TestPressKey("@a");
FinishTest("hellgoodbyeo");
// Clear the "stop recording macro keypresses because we're executing a mapping" when the mapping has finished
// executing.
clearAllMappings();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "ihello", Mappings::Recursive);
clearAllMacros();
DoTest("", "qa'ixyz\\ctrl-cq@a", "hellxyhellxyzozo");
// ... make sure that *all* mappings have finished, though: take into account recursion.
clearAllMappings();
clearAllMacros();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "ihello", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "ihello", "irecursive", Mappings::Recursive);
DoTest("", "qa'q@a", "recursivrecursivee");
clearAllMappings();
clearAllMacros();
vi_global->mappings()->add(Mappings::NormalModeMapping, "'", "ihelloixyz", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "ihello", "irecursive", Mappings::Recursive);
DoTest("", "qa'q@a", "recursivxyrecursivxyzeze");
clearAllMappings();
clearAllMacros();
// Don't save the trailing "q" with macros, and also test that we can call one macro from another,
// without one of the macros being repeated.
DoTest("", "qaixyz\\ctrl-cqqb@aq@b", "xyxyxyzzz");
clearAllMappings();
clearAllMacros();
// More stringent test that macros called from another macro aren't repeated - requires more nesting
// of macros ('a' calls 'b' calls 'c').
DoTest("", "qciC\\ctrl-cq"
"qb@ciB\\ctrl-cq"
"qa@biA\\ctrl-cq"
"dd@a", "ABC");
// Don't crash if we invoke a non-existent macro.
clearAllMacros();
DoTest("", "@x", "");
// Make macros "counted".
clearAllMacros();
DoTest("XXXX\nXXXX\nXXXX\nXXXX", "qarOljq3@a", "OXXX\nXOXX\nXXOX\nXXXO");
// A macro can be undone with one undo.
clearAllMacros();
DoTest("foo bar", "qaciwxyz\\ctrl-ci123\\ctrl-cqw@au", "xy123z bar");
// As can a counted macro.
clearAllMacros();
DoTest("XXXX\nXXXX\nXXXX\nXXXX", "qarOljq3@au", "OXXX\nXXXX\nXXXX\nXXXX");
{
EmulatedCommandBarSetUpAndTearDown vimStyleCommandBarTestsSetUpAndTearDown(vi_input_mode, kate_view, mainWindow);
// Make sure we can macro-ise an interactive sed replace.
clearAllMacros();
DoTest("foo foo foo foo\nfoo foo foo foo", "qa:s/foo/bar/gc\\enteryynyAdone\\escqggj@a", "bar bar foo bardone\nbar bar foo bardone");
// Make sure the closing "q" in the interactive sed replace isn't mistaken for a macro's closing "q".
clearAllMacros();
DoTest("foo foo foo foo\nfoo foo foo foo", "qa:s/foo/bar/gc\\enteryyqAdone\\escqggj@a", "bar bar foo foodone\nbar bar foo foodone");
clearAllMacros();
DoTest("foo foo foo foo\nfoo foo foo foo", "qa:s/foo/bar/gc\\enteryyqqAdone\\escggj@aAdone\\esc", "bar bar foo foodone\nbar bar foo foodone");
}
clearAllMappings();
clearAllMacros();
// Expand mapping in an executed macro, if the invocation of the macro "@a" is a prefix of a mapping M, and
// M ends up not being triggered.
vi_global->mappings()->add(Mappings::NormalModeMapping, "@aaaa", "idummy", Mappings::Recursive);
vi_global->mappings()->add(Mappings::NormalModeMapping, "S", "ixyz", Mappings::Recursive);
DoTest("", "qaSq@abrX", "Xyxyzz");
clearAllMappings();
// Can't play old version of macro while recording new version.
clearAllMacros();
DoTest("", "qaiaaa\\ctrl-cqqa@aq", "aaa");
// Can't play the macro while recording it.
clearAllMacros();
DoTest("", "qaiaaa\\ctrl-c@aq", "aaa");
// "@@" plays back macro "a" if "a" was the last macro we played back.
clearAllMacros();
DoTest("", "qaia\\ctrl-cq@adiw@@", "a");
// "@@" plays back macro "b" if "b" was the last macro we played back.
clearAllMacros();
DoTest("", "qbib\\ctrl-cq@bdiw@@", "b");
// "@@" does nothing if no macro was previously played.
clearAllMacros();
DoTest("", "qaia\\ctrl-cq@@", "a");
// Nitpick: "@@" replays the last played back macro, even if that macro had not been defined
// when it was first played back.
clearAllMacros();
DoTest("", "@aqaia\\ctrl-cq@@", "aa");
// "@@" is counted.
clearAllMacros();
DoTest("", "qaia\\ctrl-cq@adiw5@@", "aaaaa");
// Test that we can save and restore a single macro.
const QString viTestKConfigFileName = "vimodetest-katevimoderc";
{
clearAllMacros();
KConfig viTestKConfig(viTestKConfigFileName);
BeginTest("");
TestPressKey("qaia\\ctrl-cq");
vi_global->writeConfig(&viTestKConfig);
viTestKConfig.sync();
// Overwrite macro "a", and clear the document.
TestPressKey("qaidummy\\ctrl-cqdd");
vi_global->readConfig(&viTestKConfig);
TestPressKey("@a");
FinishTest("a");
}
{
// Test that we can save and restore several macros.
clearAllMacros();
const QString viTestKConfigFileName = "vimodetest-katevimoderc";
KConfig viTestKConfig(viTestKConfigFileName);
BeginTest("");
TestPressKey("qaia\\ctrl-cqqbib\\ctrl-cq");
vi_global->writeConfig(&viTestKConfig);
viTestKConfig.sync();
// Overwrite macros "a" & "b", and clear the document.
TestPressKey("qaidummy\\ctrl-cqqbidummy\\ctrl-cqdd");
vi_global->readConfig(&viTestKConfig);
TestPressKey("@a@b");
FinishTest("ba");
}
// Ensure that we don't crash when a "repeat change" occurs in a macro we execute.
clearAllMacros();
DoTest("", "qqixyz\\ctrl-c.q@qdd", "");
// Don't record both the "." *and* the last-change keypresses when recording a macro;
// just record the "."
clearAllMacros();
DoTest("", "ixyz\\ctrl-cqq.qddi123\\ctrl-c@q", "121233");
// Test dealing with auto-completion.
FakeCodeCompletionTestModel *fakeCodeCompletionModel = new FakeCodeCompletionTestModel(kate_view);
kate_view->registerCompletionModel(fakeCodeCompletionModel);
// Completion tests require a visible kate_view.
ensureKateViewVisible();
// Want Vim mode to intercept ctrl-p, ctrl-n shortcuts, etc.
const bool oldStealKeys = KateViewConfig::global()->viInputModeStealKeys();
KateViewConfig::global()->setViInputModeStealKeys(true);
// Don't invoke completion via ctrl-space when replaying a macro.
clearAllMacros();
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
BeginTest("");
TestPressKey("qqico\\ctrl- \\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("@q");
FinishTest("ccoo");
// Don't invoke completion via ctrl-p when replaying a macro.
clearAllMacros();
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
BeginTest("");
TestPressKey("qqico\\ctrl-p\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("@q");
FinishTest("ccoo");
// Don't invoke completion via ctrl-n when replaying a macro.
clearAllMacros();
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
BeginTest("");
TestPressKey("qqico\\ctrl-n\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("@q");
FinishTest("ccoo");
// An "enter" in insert mode when no completion is activated (so, a newline)
// is treated as a newline when replayed as a macro, even if completion is
// active when the "enter" is replayed.
clearAllMacros();
fakeCodeCompletionModel->setCompletions(QStringList()); // Prevent any completions.
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->clearWasInvoked();
BeginTest("");
TestPressKey("qqicompl\\enterX\\ctrl-cqdddd");
QVERIFY(!fakeCodeCompletionModel->wasInvoked()); // Error in test setup!
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->forceInvocationIfDocTextIs("compl");
fakeCodeCompletionModel->clearWasInvoked();
TestPressKey("@q");
QVERIFY(fakeCodeCompletionModel->wasInvoked()); // Error in test setup!
fakeCodeCompletionModel->doNotForceInvocation();
FinishTest("compl\nX");
// Same for "return".
clearAllMacros();
fakeCodeCompletionModel->setCompletions(QStringList()); // Prevent any completions.
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->clearWasInvoked();
BeginTest("");
TestPressKey("qqicompl\\returnX\\ctrl-cqdddd");
QVERIFY(!fakeCodeCompletionModel->wasInvoked()); // Error in test setup!
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->forceInvocationIfDocTextIs("compl");
fakeCodeCompletionModel->clearWasInvoked();
TestPressKey("@q");
QVERIFY(fakeCodeCompletionModel->wasInvoked()); // Error in test setup!
fakeCodeCompletionModel->doNotForceInvocation();
FinishTest("compl\nX");
// If we do a plain-text completion in a macro, this should be repeated when we replay it.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqicompl\\ctrl- \\enter\\ctrl-cq");
kate_document->clear();
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("@q");
FinishTest("completionA");
// Should replace only the current word when we repeat the completion.
clearAllMacros();
BeginTest("compl");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqfla\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("(compl)");
TestPressKey("gg@q");
FinishTest("(completionA)");
// Tail-clearing completions should be undoable with one undo.
clearAllMacros();
BeginTest("compl");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqfla\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("(compl)");
TestPressKey("gg@qu");
FinishTest("(compl)");
// Should be able to store multiple completions.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqicom\\ctrl-p\\enter com\\ctrl-p\\ctrl-p\\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("dd@q");
FinishTest("completionC completionB");
// Clear the completions for a macro when we start recording.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionOrig");
+ fakeCodeCompletionModel->setCompletions({ "completionOrig" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqicom\\ctrl- \\enter\\ctrl-cq");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionSecond");
+ fakeCodeCompletionModel->setCompletions({ "completionSecond" });
TestPressKey("ddqqicom\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("dd@q");
FinishTest("completionSecond");
// Completions are per macro.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA");
+ fakeCodeCompletionModel->setCompletions({ "completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qaicom\\ctrl- \\enter\\ctrl-cq");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionB");
+ fakeCodeCompletionModel->setCompletions({ "completionB" });
TestPressKey("ddqbicom\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("dd@aA\\enter\\ctrl-c@b");
FinishTest("completionA\ncompletionB");
// Make sure completions work with recursive macros.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA1" << "completionA2");
+ fakeCodeCompletionModel->setCompletions({ "completionA1", "completionA2" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
// Record 'a', which calls the (non-yet-existent) macro 'b'.
TestPressKey("qaicom\\ctrl- \\enter\\ctrl-cA\\enter\\ctrl-c@bA\\enter\\ctrl-cicom\\ctrl- \\ctrl-p\\enter\\ctrl-cq");
// Clear document and record 'b'.
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionB");
+ fakeCodeCompletionModel->setCompletions({ "completionB" });
TestPressKey("ggdGqbicom\\ctrl- \\enter\\ctrl-cq");
TestPressKey("dd@a");
FinishTest("completionA1\ncompletionB\ncompletionA2");
// Test that non-tail-removing completions are respected.
// Note that there is no way (in general) to determine if a completion was
// non-tail-removing, so we explicitly set the config to false.
const bool oldRemoveTailOnCompletion = KateViewConfig::global()->wordCompletionRemoveTail();
KateViewConfig::global()->setWordCompletionRemoveTail(false);
const bool oldReplaceTabsDyn = kate_document->config()->replaceTabsDyn();
kate_document->config()->setReplaceTabsDyn(false);
fakeCodeCompletionModel->setRemoveTailOnComplete(false);
clearAllMacros();
BeginTest("compTail");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "completionB" << "completionC");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "completionB", "completionC" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqfTi\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("compTail");
TestPressKey("gg@q");
FinishTest("completionATail");
// A "word" consists of letters & numbers, plus "_".
clearAllMacros();
BeginTest("(123_compTail");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqfTi\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("(123_compTail");
TestPressKey("gg@q");
FinishTest("(123_completionATail");
// Correctly remove word if we are set to remove tail.
KateViewConfig::global()->setWordCompletionRemoveTail(true);
clearAllMacros();
BeginTest("(123_compTail)");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
TestPressKey("qqfTi\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("(123_compTail)");
TestPressKey("gg@q");
FinishTest("(123_completionA)");
// Again, a "word" consists of letters & numbers & underscores.
clearAllMacros();
BeginTest("(123_compTail_456)");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
TestPressKey("qqfTi\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("(123_compTail_456)");
TestPressKey("gg@q");
FinishTest("(123_completionA)");
// Actually, let whether the tail is swallowed or not depend on the value when the
// completion occurred, not when we replay it.
clearAllMacros();
BeginTest("(123_compTail_456)");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
TestPressKey("qqfTi\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
KateViewConfig::global()->setWordCompletionRemoveTail(false);
kate_document->setText("(123_compTail_456)");
TestPressKey("gg@q");
FinishTest("(123_completionA)");
clearAllMacros();
BeginTest("(123_compTail_456)");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->setRemoveTailOnComplete(false);
KateViewConfig::global()->setWordCompletionRemoveTail(false);
TestPressKey("qqfTi\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
kate_document->setText("(123_compTail_456)");
TestPressKey("gg@q");
FinishTest("(123_completionATail_456)");
// Can have remove-tail *and* non-remove-tail completions in one macro.
clearAllMacros();
BeginTest("(123_compTail_456)\n(123_compTail_456)");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
TestPressKey("qqfTi\\ctrl- \\enter\\ctrl-c");
fakeCodeCompletionModel->setRemoveTailOnComplete(false);
KateViewConfig::global()->setWordCompletionRemoveTail(false);
TestPressKey("j^fTi\\ctrl- \\enter\\ctrl-cq");
kate_document->setText("(123_compTail_456)\n(123_compTail_456)");
TestPressKey("gg@q");
FinishTest("(123_completionA)\n(123_completionATail_456)");
// Can repeat plain-text completions when there is no word to the left of the cursor.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqi\\ctrl- \\enter\\ctrl-cq");
kate_document->clear();
TestPressKey("gg@q");
FinishTest("123_completionA");
// Shouldn't swallow the letter under the cursor if we're not swallowing tails.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->setRemoveTailOnComplete(false);
KateViewConfig::global()->setWordCompletionRemoveTail(false);
TestPressKey("qqi\\ctrl- \\enter\\ctrl-cq");
kate_document->setText("oldwordshouldbeuntouched");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("123_completionAoldwordshouldbeuntouched");
// ... but do if we are swallowing tails.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "123_completionA");
+ fakeCodeCompletionModel->setCompletions({ "123_completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
TestPressKey("qqi\\ctrl- \\enter\\ctrl-cq");
kate_document->setText("oldwordshouldbedeleted");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("123_completionA");
// Completion of functions.
// Currently, not removing the tail on function completion is not supported.
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
// A completed, no argument function "function()" is repeated correctly.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function()");
+ fakeCodeCompletionModel->setCompletions({ "function()" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("dd@q");
FinishTest("function()");
// Cursor is placed after the closing bracket when completion a no-arg function.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function()");
+ fakeCodeCompletionModel->setCompletions({ "function()" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enter.something();\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("dd@q");
FinishTest("function().something();");
// A function taking some arguments, repeated where there is no opening bracket to
// merge with, is repeated as "function()").
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enter\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("dd@q");
FinishTest("function()");
// A function taking some arguments, repeated where there is no opening bracket to
// merge with, places the cursor after the opening bracket.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enterfirstArg\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("dd@q");
FinishTest("function(firstArg)");
// A function taking some arguments, recorded where there was an opening bracket to merge
// with but repeated where there is no such bracket, is repeated as "function()" and the
// cursor placed appropriately.
BeginTest("(<-Mergeable opening bracket)");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enterfirstArg\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("dd@q");
FinishTest("function(firstArg)");
// A function taking some arguments, recorded where there was no opening bracket to merge
// with but repeated where there is such a bracket, is repeated as "function" and the
// cursor moved to after the merged opening bracket.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enterfirstArg\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("(<-firstArg goes here)");
TestPressKey("gg@q");
FinishTest("function(firstArg<-firstArg goes here)");
// A function taking some arguments, recorded where there was an opening bracket to merge
// with and repeated where there is also such a bracket, is repeated as "function" and the
// cursor moved to after the merged opening bracket.
BeginTest("(<-mergeablebracket)");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enterfirstArg\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("(<-firstArg goes here)");
TestPressKey("gg@q");
FinishTest("function(firstArg<-firstArg goes here)");
// The mergeable bracket can be separated by whitespace; the cursor is still placed after the
// opening bracket.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enterfirstArg\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText(" \t (<-firstArg goes here)");
TestPressKey("gg@q");
FinishTest("function \t (firstArg<-firstArg goes here)");
// Whitespace only, though!
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enterfirstArg\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("| \t ()");
TestPressKey("gg@q");
FinishTest("function(firstArg)| \t ()");
// The opening bracket can actually be after the current word (with optional whitespace).
// Note that this wouldn't be the case if we weren't swallowing tails when completion functions,
// but this is not currently supported.
BeginTest("function");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqfta\\ctrl- \\enterfirstArg\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("functxyz (<-firstArg goes here)");
TestPressKey("gg@q");
FinishTest("function (firstArg<-firstArg goes here)");
// Regression test for weird issue with replaying completions when the character to the left of the cursor
// is not a word char.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA");
+ fakeCodeCompletionModel->setCompletions({ "completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqciw\\ctrl- \\enter\\ctrl-cq");
TestPressKey("ddi.xyz\\enter123\\enter456\\ctrl-cggl"); // Position cursor just after the "."
TestPressKey("@q");
FinishTest(".completionA\n123\n456");
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA");
+ fakeCodeCompletionModel->setCompletions({ "completionA" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqciw\\ctrl- \\enter\\ctrl-cq");
TestPressKey("ddi.xyz.abc\\enter123\\enter456\\ctrl-cggl"); // Position cursor just after the "."
TestPressKey("@q");
FinishTest(".completionA.abc\n123\n456");
// Functions taking no arguments are never bracket-merged.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function()");
+ fakeCodeCompletionModel->setCompletions({ "function()" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifunc\\ctrl- \\enter.something();\\ctrl-cq");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("(<-don't merge this bracket)");
TestPressKey("gg@q");
FinishTest("function().something();(<-don't merge this bracket)");
// Not-removing-tail when completing functions is not currently supported,
// so ignore the "do-not-remove-tail" settings when we try this.
BeginTest("funct");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...)");
+ fakeCodeCompletionModel->setCompletions({ "function(...)" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
KateViewConfig::global()->setWordCompletionRemoveTail(false);
TestPressKey("qqfta\\ctrl- \\enterfirstArg\\ctrl-cq");
kate_document->setText("functxyz");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function(firstArg)");
BeginTest("funct");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function()");
+ fakeCodeCompletionModel->setCompletions({ "function()" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
KateViewConfig::global()->setWordCompletionRemoveTail(false);
TestPressKey("qqfta\\ctrl- \\enter\\ctrl-cq");
kate_document->setText("functxyz");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function()");
KateViewConfig::global()->setWordCompletionRemoveTail(true);
// Deal with cases where completion ends with ";".
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function();");
+ fakeCodeCompletionModel->setCompletions({ "function();" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifun\\ctrl- \\enter\\ctrl-cq");
kate_document->clear();
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function();");
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function();");
+ fakeCodeCompletionModel->setCompletions({ "function();" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifun\\ctrl- \\enterX\\ctrl-cq");
kate_document->clear();
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function();X");
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...);");
+ fakeCodeCompletionModel->setCompletions({ "function(...);" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifun\\ctrl- \\enter\\ctrl-cq");
kate_document->clear();
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function();");
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...);");
+ fakeCodeCompletionModel->setCompletions({ "function(...);" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifun\\ctrl- \\enterX\\ctrl-cq");
kate_document->clear();
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function(X);");
// Tests for completions ending in ";" where bracket merging should happen on replay.
// NB: bracket merging when recording is impossible with completions that end in ";".
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...);");
+ fakeCodeCompletionModel->setCompletions({ "function(...);" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifun\\ctrl- \\enter\\ctrl-cq");
kate_document->setText("(<-mergeable bracket");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function(<-mergeable bracket");
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function(...);");
+ fakeCodeCompletionModel->setCompletions({ "function(...);" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifun\\ctrl- \\enterX\\ctrl-cq");
kate_document->setText("(<-mergeable bracket");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function(X<-mergeable bracket");
// Don't merge no arg functions.
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "function();");
+ fakeCodeCompletionModel->setCompletions({ "function();" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqifun\\ctrl- \\enterX\\ctrl-cq");
kate_document->setText("(<-mergeable bracket");
fakeCodeCompletionModel->setFailTestOnInvocation(true);
TestPressKey("gg@q");
FinishTest("function();X(<-mergeable bracket");
{
const QString viTestKConfigFileName = "vimodetest-katevimoderc";
KConfig viTestKConfig(viTestKConfigFileName);
// Test loading and saving of macro completions.
clearAllMacros();
BeginTest("funct\nnoa\ncomtail\ncomtail\ncom");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionA" << "functionwithargs(...)" << "noargfunction()");
+ fakeCodeCompletionModel->setCompletions({ "completionA", "functionwithargs(...)", "noargfunction()" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
// Record 'a'.
TestPressKey("qafta\\ctrl- \\enterfirstArg\\ctrl-c"); // Function with args.
TestPressKey("\\enterea\\ctrl- \\enter\\ctrl-c"); // Function no args.
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
TestPressKey("\\enterfti\\ctrl- \\enter\\ctrl-c"); // Cut off tail.
fakeCodeCompletionModel->setRemoveTailOnComplete(false);
KateViewConfig::global()->setWordCompletionRemoveTail(false);
TestPressKey("\\enterfti\\ctrl- \\enter\\ctrl-cq"); // Don't cut off tail.
fakeCodeCompletionModel->setRemoveTailOnComplete(true);
KateViewConfig::global()->setWordCompletionRemoveTail(true);
// Record 'b'.
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionB" << "semicolonfunctionnoargs();" << "semicolonfunctionwithargs(...);");
+ fakeCodeCompletionModel->setCompletions({ "completionB", "semicolonfunctionnoargs();", "semicolonfunctionwithargs(...);" });
TestPressKey("\\enterqbea\\ctrl- \\enter\\ctrl-cosemicolonfunctionw\\ctrl- \\enterX\\ctrl-cosemicolonfunctionn\\ctrl- \\enterX\\ctrl-cq");
// Save.
vi_global->writeConfig(&viTestKConfig);
viTestKConfig.sync();
// Overwrite 'a' and 'b' and their completions.
- fakeCodeCompletionModel->setCompletions(QStringList() << "blah1");
+ fakeCodeCompletionModel->setCompletions({ "blah1" });
kate_document->setText("");
TestPressKey("ggqaiblah\\ctrl- \\enter\\ctrl-cq");
TestPressKey("ddqbiblah\\ctrl- \\enter\\ctrl-cq");
// Reload.
vi_global->readConfig(&viTestKConfig);
// Replay reloaded.
fakeCodeCompletionModel->setFailTestOnInvocation(true);
kate_document->setText("funct\nnoa\ncomtail\ncomtail\ncom");
TestPressKey("gg@a\\enter@b");
FinishTest("functionwithargs(firstArg)\nnoargfunction()\ncompletionA\ncompletionAtail\ncompletionB\nsemicolonfunctionwithargs(X);\nsemicolonfunctionnoargs();X");
}
// Check that undo/redo operations work properly with macros.
{
clearAllMacros();
BeginTest("");
TestPressKey("ihello\\ctrl-cqauq");
TestPressKey("@a\\enter");
FinishTest("");
}
{
clearAllMacros();
BeginTest("");
TestPressKey("ihello\\ctrl-cui.bye\\ctrl-cu");
TestPressKey("qa\\ctrl-r\\enterq");
TestPressKey("@a\\enter");
FinishTest(".bye");
}
// When replaying a last change in the process of replaying a macro, take the next completion
// event from the last change completions log, rather than the macro completions log.
// Ensure that the last change completions log is kept up to date even while we're replaying the macro.
clearAllMacros();
BeginTest("");
- fakeCodeCompletionModel->setCompletions(QStringList() << "completionMacro" << "completionRepeatLastChange");
+ fakeCodeCompletionModel->setCompletions({ "completionMacro", "completionRepeatLastChange" });
fakeCodeCompletionModel->setFailTestOnInvocation(false);
TestPressKey("qqicompletionM\\ctrl- \\enter\\ctrl-c");
TestPressKey("a completionRep\\ctrl- \\enter\\ctrl-c");
TestPressKey(".q");
qDebug() << "text: " << kate_document->text();
kate_document->clear();
TestPressKey("gg@q");
FinishTest("completionMacro completionRepeatLastChange completionRepeatLastChange");
KateViewConfig::global()->setWordCompletionRemoveTail(oldRemoveTailOnCompletion);
kate_document->config()->setReplaceTabsDyn(oldReplaceTabsDyn);
kate_view->unregisterCompletionModel(fakeCodeCompletionModel);
delete fakeCodeCompletionModel;
fakeCodeCompletionModel = nullptr;
// Hide the kate_view for subsequent tests.
kate_view->hide();
mainWindow->hide();
KateViewConfig::global()->setViInputModeStealKeys(oldStealKeys);
}
void KeysTest::MarkTests()
{
// Difference between ` and '
DoTest(" a\n b", "jmak'aii", " a\n ib");
DoTest(" a\n b", "jmak`aii", " a\ni b");
// Last edit markers.
DoTest("foo", "ean\\escgg`.r.", "foo.");
DoTest("foo", "ean\\escgg`[r[", "foo[");
DoTest("foo", "ean\\escgg`]r]", "foo]");
DoTest("foo bar", "ean\\escgg`]r]", "foon]bar");
DoTest("", "ibar\\escgg`.r.", "ba.");
DoTest("", "ibar\\escgggUiw`.r.", ".AR");
DoTest("", "2ibar\\escgg`]r]", "barba]");
DoTest("", "2ibar\\escgg`[r[", "[arbar");
DoTest("", "3ibar\\escgg`.r.", "barbar.ar"); // Vim is weird.
DoTest("", "abar\\esc.gg`]r]", "barba]");
DoTest("foo bar", "wgUiwgg`]r]", "foo BA]");
DoTest("foo bar", "wgUiwgg`.r.", "foo .AR");
DoTest("foo bar", "gUiwgg`]r.", "FO. bar");
DoTest("foo bar", "wdiwgg`[r[", "foo[");
DoTest("foo bar", "wdiwgg`]r]", "foo]");
DoTest("foo bar", "wdiwgg`.r.", "foo.");
DoTest("foo bar", "wciwnose\\escgg`.r.", "foo nos.");
DoTest("foo bar", "wciwnose\\escgg`[r[", "foo [ose");
DoTest("foo bar", "wciwnose\\escgg`]r]", "foo nos]");
DoTest("foo", "~ibar\\escgg`[r[", "F[aroo");
DoTest("foo bar", "lragg`.r.", "f.o bar");
DoTest("foo bar", "lragg`[r[", "f[o bar");
DoTest("foo bar", "lragg`]r]", "f]o bar");
DoTest("", "ifoo\\ctrl-hbar\\esc`[r[", "[obar");
DoTest("", "ifoo\\ctrl-wbar\\esc`[r[", "[ar");
DoTest("", "if\\ctrl-hbar\\esc`[r[", "[ar");
DoTest("", "5ofoo\\escgg`[r[", "\n[oo\nfoo\nfoo\nfoo\nfoo");
DoTest("", "5ofoo\\escgg`]r]", "\nfoo\nfoo\nfoo\nfoo\nfo]");
DoTest("", "5ofoo\\escgg`.r.", "\nfoo\nfoo\nfoo\nfoo\n.oo");
DoTest("foo", "yyp`[r[", "foo\n[oo");
DoTest("xyz\nfoo", "ja\\returnbar\\esc`[r[", "xyz\n[\nbaroo");
DoTest("foo", "lrayypgg`[r[", "fao\n[ao");
DoTest("foo", "l~u`[r[", "[oo");
DoTest("foo", "l~u`.r.", ".oo");
DoTest("foo", "l~u`]r]", "]oo");
DoTest("foo", "lia\\escu`[r[", "[oo");
DoTest("foo", "lia\\escu`.r.", ".oo");
DoTest("foo", "lia\\escu`]r]", "]oo");
DoTest("foo", "l~u~`[r[", "f[o");
DoTest("foo\nbar\nxyz", "jyypu`[r[", "foo\nbar\n[yz");
DoTest("foo\nbar\nxyz", "jyypu`.r.", "foo\nbar\n.yz");
DoTest("foo\nbar\nxyz", "jyypu`]r]", "foo\nbar\n]yz");
DoTest("foo\nbar\nxyz\n123", "jdju`[r[", "foo\n[ar\nxyz\n123");
DoTest("foo\nbar\nxyz\n123", "jdju`.r.", "foo\n.ar\nxyz\n123");
DoTest("foo\nbar\nxyz\n123", "jdju`]r]", "foo\nbar\n]yz\n123");
DoTest("foo\nbar\nxyz\n123", "jVj~u\\esc`[r[", "foo\n[ar\nxyz\n123", ShouldFail, "Vim is weird.");
}
//END: KeysTest
diff --git a/autotests/src/vimode/view.cpp b/autotests/src/vimode/view.cpp
index e5b9e5aa..2f357170 100644
--- a/autotests/src/vimode/view.cpp
+++ b/autotests/src/vimode/view.cpp
@@ -1,422 +1,422 @@
/*
* This file is part of the KDE libraries
*
* Copyright (C) 2014 Miquel Sabaté Solà
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include
#include
#include
#include
#include "view.h"
using namespace KTextEditor;
QTEST_MAIN(ViewTest)
void ViewTest::yankHighlightingTests()
{
const QColor yankHighlightColour = kate_view->renderer()->config()->savedLineColor();
BeginTest("foo bar xyz");
const QList rangesInitial = rangesOnFirstLine();
Q_ASSERT(rangesInitial.isEmpty() && "Assumptions about ranges are wrong - this test is invalid and may need updating!");
TestPressKey("wyiw");
{
const QList rangesAfterYank = rangesOnFirstLine();
QCOMPARE(rangesAfterYank.size(), rangesInitial.size() + 1);
QCOMPARE(rangesAfterYank.first()->attribute()->background().color(), yankHighlightColour);
QCOMPARE(rangesAfterYank.first()->start().line(), 0);
QCOMPARE(rangesAfterYank.first()->start().column(), 4);
QCOMPARE(rangesAfterYank.first()->end().line(), 0);
QCOMPARE(rangesAfterYank.first()->end().column(), 7);
}
FinishTest("foo bar xyz");
BeginTest("foom bar xyz");
TestPressKey("wY");
{
const QList rangesAfterYank = rangesOnFirstLine();
QCOMPARE(rangesAfterYank.size(), rangesInitial.size() + 1);
QCOMPARE(rangesAfterYank.first()->attribute()->background().color(), yankHighlightColour);
QCOMPARE(rangesAfterYank.first()->start().line(), 0);
QCOMPARE(rangesAfterYank.first()->start().column(), 5);
QCOMPARE(rangesAfterYank.first()->end().line(), 0);
QCOMPARE(rangesAfterYank.first()->end().column(), 12);
}
FinishTest("foom bar xyz");
// Unhighlight on keypress.
DoTest("foo bar xyz", "yiww", "foo bar xyz");
QCOMPARE(rangesOnFirstLine().size(), rangesInitial.size());
// Update colour on config change.
DoTest("foo bar xyz", "yiw", "foo bar xyz");
const QColor newYankHighlightColour = QColor(255, 0, 0);
kate_view->renderer()->config()->setSavedLineColor(newYankHighlightColour);
QCOMPARE(rangesOnFirstLine().first()->attribute()->background().color(), newYankHighlightColour);
// Visual Mode.
DoTest("foo", "viwy", "foo");
QCOMPARE(rangesOnFirstLine().size(), rangesInitial.size() + 1);
// Unhighlight on keypress in Visual Mode
DoTest("foo", "viwyw", "foo");
QCOMPARE(rangesOnFirstLine().size(), rangesInitial.size());
// Add a yank highlight and directly (i.e. without using Vim commands,
// which would clear the highlight) delete all text; if this deletes the yank highlight behind our back
// and we don't respond correctly to this, it will be double-deleted by KateViNormalMode.
// Currently, this seems like it doesn't occur, but better safe than sorry :)
BeginTest("foo bar xyz");
TestPressKey("yiw");
QCOMPARE(rangesOnFirstLine().size(), rangesInitial.size() + 1);
kate_document->documentReload();
kate_document->clear();
vi_input_mode->reset();
vi_input_mode_manager = vi_input_mode->viInputModeManager();
FinishTest("");
}
void ViewTest::visualLineUpDownTests()
{
// Need to ensure we have dynamic wrap, a fixed width font, and a decent size kate_view.
ensureKateViewVisible();
const QSize oldSize = kate_view->size();
kate_view->resize(400, 400); // Default size is too cramped to have interesting text in.
const QFont oldFont = kate_view->renderer()->config()->font();
- QFont fixedWidthFont("Monospace");
+ QFont fixedWidthFont("Courier");
fixedWidthFont.setStyleHint(QFont::TypeWriter);
Q_ASSERT_X(QFontInfo(fixedWidthFont).fixedPitch(), "setting up visual line up down tests", "Need a fixed pitch font!");
kate_view->renderer()->config()->setFont(fixedWidthFont);
const bool oldDynWordWrap = KateViewConfig::global()->dynWordWrap();
KateViewConfig::global()->setDynWordWrap(true);
const bool oldReplaceTabsDyn = kate_document->config()->replaceTabsDyn();
kate_document->config()->setReplaceTabsDyn(false);
const int oldTabWidth = kate_document->config()->tabWidth();
const int tabWidth = 5;
kate_document->config()->setTabWidth(tabWidth);
KateViewConfig::global()->setShowScrollbars(0);
// Compute the maximum width of text before line-wrapping sets it.
int textWrappingLength = 1;
while (true) {
QString text = QString("X").repeated(textWrappingLength) + ' ' + 'O';
const int posOfO = text.length() - 1;
kate_document->setText(text);
if (kate_view->cursorToCoordinate(Cursor(0, posOfO)).y() != kate_view->cursorToCoordinate(Cursor(0, 0)).y()) {
textWrappingLength++; // Number of x's, plus space.
break;
}
textWrappingLength++;
}
const QString fillsLineAndEndsOnSpace = QString("X").repeated(textWrappingLength - 1) + ' ';
// Create a QString consisting of enough concatenated fillsLineAndEndsOnSpace to completely
// fill the viewport of the kate View.
QString fillsView = fillsLineAndEndsOnSpace;
while (true) {
kate_document->setText(fillsView);
const QString visibleText = kate_document->text(kate_view->visibleRange());
if (fillsView.length() > visibleText.length() * 2) { // Overkill.
break;
}
fillsView += fillsLineAndEndsOnSpace;
}
const int numVisibleLinesToFillView = fillsView.length() / fillsLineAndEndsOnSpace.length();
{
// gk/ gj when there is only one line.
DoTest("foo", "lgkr.", "f.o");
DoTest("foo", "lgjr.", "f.o");
}
{
// gk when sticky bit is set to the end.
const QString originalText = fillsLineAndEndsOnSpace.repeated(2);
QString expectedText = originalText;
kate_document->setText(originalText);
Q_ASSERT(expectedText[textWrappingLength - 1] == ' ');
expectedText[textWrappingLength - 1] = '.';
DoTest(originalText, "$gkr.", expectedText);
}
{
// Regression test: more than fill the view up, go to end, and do gk on wrapped text (used to crash).
// First work out the text that will fill up the view.
QString expectedText = fillsView;
Q_ASSERT(expectedText[expectedText.length() - textWrappingLength - 1] == ' ');
expectedText[expectedText.length() - textWrappingLength - 1] = '.';
DoTest(fillsView, "$gkr.", expectedText);
}
{
// Jump down a few lines all in one go, where we have some variable length lines to navigate.
const int numVisualLinesOnLine[] = { 3, 5, 2, 3 };
const int numLines = sizeof(numVisualLinesOnLine) / sizeof(int);
const int startVisualLine = 2;
const int numberLinesToGoDownInOneGo = 10;
int totalVisualLines = 0;
for (int i = 0; i < numLines; i++) {
totalVisualLines += numVisualLinesOnLine[i];
}
QString startText;
for (int i = 0; i < numLines; i++) {
QString thisLine = fillsLineAndEndsOnSpace.repeated(numVisualLinesOnLine[i]);
// Replace trailing space with carriage return.
thisLine.chop(1);
thisLine.append('\n');
startText += thisLine;
}
QString expectedText = startText;
expectedText[((startVisualLine - 1) + numberLinesToGoDownInOneGo) * fillsLineAndEndsOnSpace.length()] = '.';
Q_ASSERT(numberLinesToGoDownInOneGo + startVisualLine < totalVisualLines);
Q_ASSERT(numberLinesToGoDownInOneGo + startVisualLine < numVisibleLinesToFillView);
DoTest(startText, QString("gj").repeated(startVisualLine - 1) + QString::number(numberLinesToGoDownInOneGo) + "gjr.", expectedText);
// Now go up a few lines.
const int numLinesToGoBackUp = 7;
expectedText = startText;
expectedText[((startVisualLine - 1) + numberLinesToGoDownInOneGo - numLinesToGoBackUp) * fillsLineAndEndsOnSpace.length()] = '.';
DoTest(startText, QString("gj").repeated(startVisualLine - 1) + QString::number(numberLinesToGoDownInOneGo) + "gj" + QString::number(numLinesToGoBackUp) + "gkr.", expectedText);
}
{
// Move down enough lines in one go to disappear off the view.
// About half-a-viewport past the end of the current viewport.
const int numberLinesToGoDown = numVisibleLinesToFillView * 3 / 2;
const int visualColumnNumber = 7;
Q_ASSERT(fillsLineAndEndsOnSpace.length() > visualColumnNumber);
QString expectedText = fillsView.repeated(2);
Q_ASSERT(expectedText[expectedText.length() - textWrappingLength - 1] == ' ');
expectedText[visualColumnNumber + fillsLineAndEndsOnSpace.length() * numberLinesToGoDown] = '.';
DoTest(fillsView.repeated(2), QString("l").repeated(visualColumnNumber) + QString::number(numberLinesToGoDown) + "gjr.", expectedText);
}
{
// Deal with dynamic wrapping and indented blocks - continuations of a line are "invisibly" idented by
// the same amount as the beginning of the line, and we have to subtract this indentation.
const QString unindentedFirstLine = "stickyhelper\n";
const int numIndentationSpaces = 5;
Q_ASSERT(textWrappingLength > numIndentationSpaces * 2 /* keep some wriggle room */);
const QString indentedFillsLineEndsOnSpace = QString(" ").repeated(numIndentationSpaces) + QString("X").repeated(textWrappingLength - 1 - numIndentationSpaces) + ' ';
DoTest(unindentedFirstLine + indentedFillsLineEndsOnSpace + "LINE3", QString("l").repeated(numIndentationSpaces) + "jgjr.", unindentedFirstLine + indentedFillsLineEndsOnSpace + ".INE3");
// The first, non-wrapped portion of the line is not invisibly indented, though, so ensure we don't mess that up.
QString expectedSecondLine = indentedFillsLineEndsOnSpace;
expectedSecondLine[numIndentationSpaces] = '.';
DoTest(unindentedFirstLine + indentedFillsLineEndsOnSpace + "LINE3", QString("l").repeated(numIndentationSpaces) + "jgjgkr.", unindentedFirstLine + expectedSecondLine + "LINE3");
}
{
// Take into account any invisible indentation when setting the sticky column.
const int numIndentationSpaces = 5;
Q_ASSERT(textWrappingLength > numIndentationSpaces * 2 /* keep some wriggle room */);
const QString indentedFillsLineEndsOnSpace = QString(" ").repeated(numIndentationSpaces) + QString("X").repeated(textWrappingLength - 1 - numIndentationSpaces) + ' ';
const int posInSecondWrappedLineToChange = 3;
QString expectedText = indentedFillsLineEndsOnSpace + fillsLineAndEndsOnSpace;
expectedText[textWrappingLength + posInSecondWrappedLineToChange] = '.';
DoTest(indentedFillsLineEndsOnSpace + fillsLineAndEndsOnSpace, QString::number(textWrappingLength + posInSecondWrappedLineToChange) + "lgkgjr.", expectedText);
// Make sure we can do this more than once (i.e. clear any flags that need clearing).
DoTest(indentedFillsLineEndsOnSpace + fillsLineAndEndsOnSpace, QString::number(textWrappingLength + posInSecondWrappedLineToChange) + "lgkgjr.", expectedText);
}
{
// Take into account any invisible indentation when setting the sticky column as above, but use tabs.
const QString indentedFillsLineEndsOnSpace = QString("\t") + QString("X").repeated(textWrappingLength - 1 - tabWidth) + ' ';
const int posInSecondWrappedLineToChange = 3;
QString expectedText = indentedFillsLineEndsOnSpace + fillsLineAndEndsOnSpace;
expectedText[textWrappingLength - tabWidth + posInSecondWrappedLineToChange] = '.';
DoTest(indentedFillsLineEndsOnSpace + fillsLineAndEndsOnSpace, QString("fXf ") + QString::number(posInSecondWrappedLineToChange) + "lgkgjr.", expectedText);
}
{
// Deal with the fact that j/ k may set a sticky column that is impossible to adhere to in visual mode because
// it is too high.
// Here, we have one dummy line and one wrapped line. We start from the beginning of the wrapped line and
// move right until we wrap and end up at posInWrappedLineToChange one the second line of the wrapped line.
// We then move up and down with j and k to set the sticky column to a value to large to adhere to in a
// visual line, and try to move a visual line up.
const QString dummyLineForUseWithK("dummylineforusewithk\n");
QString startText = dummyLineForUseWithK + fillsLineAndEndsOnSpace.repeated(2);
const int posInWrappedLineToChange = 3;
QString expectedText = startText;
expectedText[dummyLineForUseWithK.length() + posInWrappedLineToChange] = '.';
DoTest(startText, "j" + QString::number(textWrappingLength + posInWrappedLineToChange) + "lkjgkr.", expectedText);
}
{
// Ensure gj works in Visual mode.
Q_ASSERT(fillsLineAndEndsOnSpace.toLower() != fillsLineAndEndsOnSpace);
QString expectedText = fillsLineAndEndsOnSpace.toLower() + fillsLineAndEndsOnSpace;
expectedText[textWrappingLength] = expectedText[textWrappingLength].toLower();
DoTest(fillsLineAndEndsOnSpace.repeated(2), "vgjgu", expectedText);
}
{
// Ensure gk works in Visual mode.
Q_ASSERT(fillsLineAndEndsOnSpace.toLower() != fillsLineAndEndsOnSpace);
DoTest(fillsLineAndEndsOnSpace.repeated(2), "$vgkgu", fillsLineAndEndsOnSpace + fillsLineAndEndsOnSpace.toLower());
}
{
// Some tests for how well we handle things with real tabs.
QString beginsWithTabFillsLineEndsOnSpace = "\t";
while (beginsWithTabFillsLineEndsOnSpace.length() + (tabWidth - 1) < textWrappingLength - 1) {
beginsWithTabFillsLineEndsOnSpace += 'X';
}
beginsWithTabFillsLineEndsOnSpace += ' ';
const QString unindentedFirstLine = "stockyhelper\n";
const int posOnThirdLineToChange = 3;
QString expectedThirdLine = fillsLineAndEndsOnSpace;
expectedThirdLine[posOnThirdLineToChange] = '.';
DoTest(unindentedFirstLine + beginsWithTabFillsLineEndsOnSpace + fillsLineAndEndsOnSpace,
QString("l").repeated(tabWidth + posOnThirdLineToChange) + "gjgjr.",
unindentedFirstLine + beginsWithTabFillsLineEndsOnSpace + expectedThirdLine);
// As above, but go down twice and return to the middle line.
const int posOnSecondLineToChange = 2;
QString expectedSecondLine = beginsWithTabFillsLineEndsOnSpace;
expectedSecondLine[posOnSecondLineToChange + 1 /* "+1" as we're not counting the leading tab as a pos */] = '.';
DoTest(unindentedFirstLine + beginsWithTabFillsLineEndsOnSpace + fillsLineAndEndsOnSpace,
QString("l").repeated(tabWidth + posOnSecondLineToChange) + "gjgjgkr.",
unindentedFirstLine + expectedSecondLine + fillsLineAndEndsOnSpace);
}
// Restore back to how we were before.
kate_view->resize(oldSize);
kate_view->renderer()->config()->setFont(oldFont);
KateViewConfig::global()->setDynWordWrap(oldDynWordWrap);
kate_document->config()->setReplaceTabsDyn(oldReplaceTabsDyn);
kate_document->config()->setTabWidth(oldTabWidth);
}
void ViewTest::ScrollViewTests()
{
QSKIP("This is too unstable in Jenkins", SkipAll);
// First of all, we have to initialize some sizes and fonts.
ensureKateViewVisible();
const QSize oldSize = kate_view->size();
kate_view->resize(200, 200);
const QFont oldFont = kate_view->renderer()->config()->font();
QFont fixedWidthFont("Monospace");
fixedWidthFont.setStyleHint(QFont::TypeWriter);
fixedWidthFont.setPixelSize(14);
Q_ASSERT_X(QFontInfo(fixedWidthFont).fixedPitch(),
"setting up ScrollViewTests", "Need a fixed pitch font!");
kate_view->renderer()->config()->setFont(fixedWidthFont);
// Generating our text here.
QString text;
for (int i = 0; i < 20; i++) {
text += " aaaaaaaaaaaaaaaa\n";
}
// TODO: fix the visibleRange's tests.
// zz
BeginTest(text);
TestPressKey("10l9jzz");
QCOMPARE(kate_view->cursorPosition().line(), 9);
QCOMPARE(kate_view->cursorPosition().column(), 10);
QCOMPARE(kate_view->visibleRange(), Range(4, 0, 13, 20));
FinishTest(text);
// z.
BeginTest(text);
TestPressKey("10l9jz.");
QCOMPARE(kate_view->cursorPosition().line(), 9);
QCOMPARE(kate_view->cursorPosition().column(), 4);
QCOMPARE(kate_view->visibleRange(), Range(4, 0, 13, 20));
FinishTest(text);
// zt
BeginTest(text);
TestPressKey("10l9jzt");
QCOMPARE(kate_view->cursorPosition().line(), 9);
QCOMPARE(kate_view->cursorPosition().column(), 10);
QCOMPARE(kate_view->visibleRange(), Range(9, 0, 18, 20));
FinishTest(text);
// z
BeginTest(text);
TestPressKey("10l9jz\\return");
QCOMPARE(kate_view->cursorPosition().line(), 9);
QCOMPARE(kate_view->cursorPosition().column(), 4);
QCOMPARE(kate_view->visibleRange(), Range(9, 0, 18, 20));
FinishTest(text);
// zb
BeginTest(text);
TestPressKey("10l9jzb");
QCOMPARE(kate_view->cursorPosition().line(), 9);
QCOMPARE(kate_view->cursorPosition().column(), 10);
QCOMPARE(kate_view->visibleRange(), Range(0, 0, 9, 20));
FinishTest(text);
// z-
BeginTest(text);
TestPressKey("10l9jz-");
QCOMPARE(kate_view->cursorPosition().line(), 9);
QCOMPARE(kate_view->cursorPosition().column(), 4);
QCOMPARE(kate_view->visibleRange(), Range(0, 0, 9, 20));
FinishTest(text);
// Restore back to how we were before.
kate_view->resize(oldSize);
kate_view->renderer()->config()->setFont(oldFont);
}
void ViewTest::clipboardTests_data()
{
QTest::addColumn("text");
QTest::addColumn("commands");
QTest::addColumn("clipboard");
QTest::newRow("yank") << "yyfoo\nbar" << "yy" << "yyfoo\n";
QTest::newRow("delete") << "ddfoo\nbar" << "dd" << "ddfoo\n";
QTest::newRow("yank empty line") << "\nbar" << "yy" << QString();
QTest::newRow("delete word") << "word foo" << "dw" << "word ";
QTest::newRow("delete onechar word") << "w foo" << "dw" << "w ";
QTest::newRow("delete onechar") << "word foo" << "dc" << QString();
QTest::newRow("delete empty lines") << " \t\n\n \nfoo" << "d3d" << QString();
}
void ViewTest::clipboardTests()
{
QFETCH(QString, text);
QFETCH(QString, commands);
QFETCH(QString, clipboard);
QApplication::clipboard()->clear();
BeginTest(text);
TestPressKey(commands);
QCOMPARE(QApplication::clipboard()->text(), clipboard);
}
QList ViewTest::rangesOnFirstLine()
{
return kate_document->buffer().rangesForLine(0, kate_view, true);
}
diff --git a/src/buffer/katesecuretextbuffer.cpp b/src/buffer/katesecuretextbuffer.cpp
index b22fda98..26e0a10d 100644
--- a/src/buffer/katesecuretextbuffer.cpp
+++ b/src/buffer/katesecuretextbuffer.cpp
@@ -1,168 +1,168 @@
/* This file is part of the KTextEditor project.
*
* Copyright (C) 2017 KDE Developers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "katesecuretextbuffer_p.h"
#include "config.h"
#ifndef Q_OS_WIN
#include
#include
#endif
#include
#include
#include
#include
#include
KAUTH_HELPER_MAIN("org.kde.ktexteditor.katetextbuffer", SecureTextBuffer)
ActionReply SecureTextBuffer::savefile(const QVariantMap &args)
{
- const QString sourceFile = args[QLatin1String("sourceFile")].toString();
- const QString targetFile = args[QLatin1String("targetFile")].toString();
- const QByteArray checksum = args[QLatin1String("checksum")].toByteArray();
- const uint ownerId = (uint) args[QLatin1String("ownerId")].toInt();
- const uint groupId = (uint) args[QLatin1String("groupId")].toInt();
+ const QString sourceFile = args[QStringLiteral("sourceFile")].toString();
+ const QString targetFile = args[QStringLiteral("targetFile")].toString();
+ const QByteArray checksum = args[QStringLiteral("checksum")].toByteArray();
+ const uint ownerId = (uint) args[QStringLiteral("ownerId")].toInt();
+ const uint groupId = (uint) args[QStringLiteral("groupId")].toInt();
if (saveFileInternal(sourceFile, targetFile, checksum, ownerId, groupId)) {
return ActionReply::SuccessReply();
}
return ActionReply::HelperErrorReply();
}
bool SecureTextBuffer::saveFileInternal(const QString &sourceFile, const QString &targetFile,
const QByteArray &checksum, const uint ownerId, const uint groupId)
{
QFileInfo targetFileInfo(targetFile);
if (!QDir::setCurrent(targetFileInfo.dir().path())) {
return false;
}
// get information about target file
const QString targetFileName = targetFileInfo.fileName();
targetFileInfo.setFile(targetFileName);
const bool newFile = !targetFileInfo.exists();
// open source and target file
QFile readFile(sourceFile);
//TODO use QSaveFile for saving contents and automatic atomic move on commit() when QSaveFile's security problem
// (default temporary file permissions) is fixed
//
// We will first generate temporary filename and then use it relatively to prevent an attacker
// to trick us to write contents to a different file by changing underlying directory.
QTemporaryFile tempFile(targetFileName);
if (!tempFile.open()) {
return false;
}
tempFile.close();
QString tempFileName = QFileInfo(tempFile).fileName();
tempFile.setFileName(tempFileName);
if (!readFile.open(QIODevice::ReadOnly) || !tempFile.open()) {
return false;
}
const int tempFileDescriptor = tempFile.handle();
// prepare checksum maker
QCryptographicHash cryptographicHash(checksumAlgorithm);
// copy contents
char buffer[bufferLength];
qint64 read = -1;
while ((read = readFile.read(buffer, bufferLength)) > 0) {
cryptographicHash.addData(buffer, read);
if (tempFile.write(buffer, read) == -1) {
return false;
}
}
// check that copying was successful and checksum matched
QByteArray localChecksum = cryptographicHash.result();
if (read == -1 || localChecksum != checksum || !tempFile.flush()) {
return false;
}
tempFile.close();
if (newFile) {
// ensure new file is readable by anyone
tempFile.setPermissions(tempFile.permissions() | QFile::Permission::ReadGroup | QFile::Permission::ReadOther);
} else {
// ensure the same file permissions
tempFile.setPermissions(targetFileInfo.permissions());
// ensure file has the same owner and group as before
setOwner(tempFileDescriptor, ownerId, groupId);
}
// rename temporary file to the target file
if (moveFile(tempFileName, targetFileName)) {
// temporary file was renamed, there is nothing to remove anymore
tempFile.setAutoRemove(false);
return true;
}
return false;
}
void SecureTextBuffer::setOwner(const int filedes, const uint ownerId, const uint groupId)
{
#ifndef Q_OS_WIN
if (ownerId != (uint)-2 && groupId != (uint)-2) {
const int result = fchown(filedes, ownerId, groupId);
// set at least correct group if owner cannot be changed
if (result != 0 && errno == EPERM) {
fchown(filedes, getuid(), groupId);
}
}
#else
// no-op for windows
#endif
}
bool SecureTextBuffer::moveFile(const QString &sourceFile, const QString &targetFile)
{
#ifndef Q_OS_WIN
const int result = std::rename(QFile::encodeName(sourceFile).constData(), QFile::encodeName(targetFile).constData());
if (result == 0) {
syncToDisk(QFile(targetFile).handle());
return true;
}
return false;
#else
// use racy fallback for windows
QFile::remove(targetFile);
return QFile::rename(sourceFile, targetFile);
#endif
}
void SecureTextBuffer::syncToDisk(const int fd)
{
#ifndef Q_OS_WIN
#if HAVE_FDATASYNC
fdatasync(fd);
#else
fsync(fd);
#endif
#else
// no-op for windows
#endif
}
diff --git a/src/buffer/org.kde.ktexteditor.katetextbuffer.actions b/src/buffer/org.kde.ktexteditor.katetextbuffer.actions
index 145d9882..2cdc63d2 100644
--- a/src/buffer/org.kde.ktexteditor.katetextbuffer.actions
+++ b/src/buffer/org.kde.ktexteditor.katetextbuffer.actions
@@ -1,99 +1,105 @@
[Domain]
Name=Document Actions
Name[ca]=Accions de document
Name[ca@valencia]=Accions de document
Name[cs]=Činnosti dokumentu
Name[da]=Dokumenthandlinger
Name[de]=Dokument-Aktionen
Name[en_GB]=Document Actions
Name[es]=Acciones de documento
Name[eu]=Dokumentuen ekintzak
Name[fi]=Tiedosto-toiminnot
Name[fr]=Actions du document
Name[gl]=Accións do documento
Name[ia]=Actiones de documento
Name[it]=Azioni documenti
+Name[ko]=문서 동작
Name[nl]=Documentacties
Name[nn]=Dokumenthandlingar
Name[pl]=Działania na dokumentach
Name[pt]=Acções do Documento
+Name[pt_BR]=Ações do documento
Name[ru]=Действия над документом
Name[sl]=Dejanja dokumenta
Name[sr]=Радње над документом
Name[sr@ijekavian]=Радње над документом
Name[sr@ijekavianlatin]=Radnje nad dokumentom
Name[sr@latin]=Radnje nad dokumentom
Name[sv]=Dokumentåtgärder
Name[tr]=Belge İşlemleri
Name[uk]=Дії над документом
Name[x-test]=xxDocument Actionsxx
Name[zh_CN]=文档动作
Name[zh_TW]=文件動作
Policy=auth_admin
Persistence=session
[org.kde.ktexteditor.katetextbuffer.savefile]
Name=Save Document
Name[ast]=Guardar documentu
Name[ca]=Desa el document
Name[ca@valencia]=Guarda el document
Name[cs]=Uložit dokument
Name[da]=Gem dokument
Name[de]=Dokument speichern
Name[en_GB]=Save Document
Name[es]=Guardar documento
Name[eu]=Gorde dokumentua
Name[fi]=Tallenna tiedosto
Name[fr]=Enregistrer le document
Name[gl]=Gardar o documento
Name[ia]=Salveguarda documento
Name[it]=Salva documento
+Name[ko]=문서 저장
Name[nl]=Document opslaan
Name[nn]=Lagra dokument
Name[pl]=Zapisz dokument
Name[pt]=Gravar o Documento
+Name[pt_BR]=Salvar documento
Name[ru]=Сохранение документа
Name[sl]=Shrani dokument
Name[sr]=Сачувај документ
Name[sr@ijekavian]=Сачувај документ
Name[sr@ijekavianlatin]=Sačuvaj dokument
Name[sr@latin]=Sačuvaj dokument
Name[sv]=Spara dokument
Name[tr]=Belgeyi Kaydet
Name[uk]=Зберегти документ
Name[x-test]=xxSave Documentxx
Name[zh_CN]=保存文档
Name[zh_TW]=儲存文件
Description=Root privileges are needed to save this document
Description[ast]=Precísense privilexos root pa guardar esti documentu
Description[ca]=Es requereixen privilegis d'administrador per desar aquest document
Description[ca@valencia]=Es requereixen privilegis d'administrador per guardar este document
Description[cs]=K uložení dokumentu je potřeba práva uživatele root
Description[da]=Root-rettigheder kræves for at gemme dette dokument
Description[de]=Rechte als Systemverwalter sind für das Speichern diese Dokuments erforderlich
Description[en_GB]=Root privileges are needed to save this document
Description[es]=Se necesitan permisos de «root» para guardar este documento
Description[eu]=Root pribilegioak behar dira dokumentu hau gordetzeko
Description[fi]=Tämän tiedoston tallentamiseen tarvitaan pääkäyttäjän oikeudet
Description[fr]=Vous devez disposer des privilèges de superutilisateur pour enregistrer ce document
Description[gl]=Necesítanse privilexios de administrador para gardar este documento.
Description[ia]=Privilegios de radice root es necessari per salveguardar iste documento
Description[it]=Sono necessari i privilegi di root per salvare questo documento
+Description[ko]=이 문서를 저장하려면 루트 권한이 필요함
Description[nl]=Om dit document op te slaan zijn root-rechten nodig
Description[nn]=Du må ha rotløyve for å kunna lagra dokumentet
Description[pl]=Wymagane są uprawnienia administratora do zapisania tego dokumentu
Description[pt]=São necessários privilégios de 'root' para gravar este documento
+Description[pt_BR]=São necessários privilégios de root para salvar este documento
Description[ru]=Для сохранения этого документа необходимы права администратора
Description[sl]=Za shranjevanje tega dokumenta so zahtevana skrbniška dovoljenja
Description[sr]=Уписивање овог документа захтева корена овлашћења
Description[sr@ijekavian]=Уписивање овог документа захтева корена овлашћења
Description[sr@ijekavianlatin]=Upisivanje ovog dokumenta zahteva korena ovlašćenja
Description[sr@latin]=Upisivanje ovog dokumenta zahteva korena ovlašćenja
Description[sv]=Systemadministratörsprivilegier krävs för att spara dokumentet
Description[tr]=Bu belgeyi kaydetmek için yönetici ayrıcalıkları gereklidir
Description[uk]=Для збереження документа потрібні права доступу користувача root
Description[x-test]=xxRoot privileges are needed to save this documentxx
Description[zh_CN]=保存文档需要超级用户权限
Description[zh_TW]=需要 root 權限以儲存此文件
Policy=auth_admin
Persistence=session
diff --git a/src/completion/katewordcompletion.cpp b/src/completion/katewordcompletion.cpp
index 51cb7c89..e836ee94 100644
--- a/src/completion/katewordcompletion.cpp
+++ b/src/completion/katewordcompletion.cpp
@@ -1,583 +1,583 @@
/* This file is part of the KDE libraries and the Kate part.
*
* Copyright (C) 2003 Anders Lund
* Copyright (C) 2010 Christoph Cullmann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
//BEGIN includes
#include "katewordcompletion.h"
#include "kateview.h"
#include "kateconfig.h"
#include "katedocument.h"
#include "kateglobal.h"
#include "katepartdebug.h"
#include "katedefaultcolors.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
-#include
+#include
#include
#include
#include
#include
#include
#include
#include
//END
/// Amount of characters the document may have to enable automatic invocation (1MB)
static const int autoInvocationMaxFilesize = 1000000;
//BEGIN KateWordCompletionModel
KateWordCompletionModel::KateWordCompletionModel(QObject *parent)
: CodeCompletionModel (parent)
, m_automatic(false)
{
setHasGroups(false);
}
KateWordCompletionModel::~KateWordCompletionModel()
{
}
void KateWordCompletionModel::saveMatches(KTextEditor::View *view,
const KTextEditor::Range &range)
{
m_matches = allMatches(view, range);
m_matches.sort();
}
QVariant KateWordCompletionModel::data(const QModelIndex &index, int role) const
{
if (role == UnimportantItemRole) {
return QVariant(true);
}
if (role == InheritanceDepth) {
return 10000;
}
if (!index.parent().isValid()) {
//It is the group header
switch (role) {
case Qt::DisplayRole:
return i18n("Auto Word Completion");
case GroupRole:
return Qt::DisplayRole;
}
}
if (index.column() == KTextEditor::CodeCompletionModel::Name && role == Qt::DisplayRole) {
return m_matches.at(index.row());
}
if (index.column() == KTextEditor::CodeCompletionModel::Icon && role == Qt::DecorationRole) {
static QIcon icon(QIcon::fromTheme(QStringLiteral("insert-text")).pixmap(QSize(16, 16)));
return icon;
}
return QVariant();
}
QModelIndex KateWordCompletionModel::parent(const QModelIndex &index) const
{
if (index.internalId()) {
return createIndex(0, 0, quintptr(0));
} else {
return QModelIndex();
}
}
QModelIndex KateWordCompletionModel::index(int row, int column, const QModelIndex &parent) const
{
if (!parent.isValid()) {
if (row == 0) {
return createIndex(row, column, quintptr(0));
} else {
return QModelIndex();
}
} else if (parent.parent().isValid()) {
return QModelIndex();
}
if (row < 0 || row >= m_matches.count() || column < 0 || column >= ColumnCount) {
return QModelIndex();
}
return createIndex(row, column, 1);
}
int KateWordCompletionModel::rowCount(const QModelIndex &parent) const
{
if (!parent.isValid() && !m_matches.isEmpty()) {
return 1; //One root node to define the custom group
} else if (parent.parent().isValid()) {
return 0; //Completion-items have no children
} else {
return m_matches.count();
}
}
bool KateWordCompletionModel::shouldStartCompletion(KTextEditor::View *view, const QString &insertedText, bool userInsertion, const KTextEditor::Cursor &position)
{
if (!userInsertion) {
return false;
}
if (insertedText.isEmpty()) {
return false;
}
KTextEditor::ViewPrivate *v = qobject_cast (view);
if (view->document()->totalCharacters() > autoInvocationMaxFilesize) {
// Disable automatic invocation for files larger than 1MB (see benchmarks)
return false;
}
const QString &text = view->document()->line(position.line()).left(position.column());
const uint check = v->config()->wordCompletionMinimalWordLength();
// Start completion immediately if min. word size is zero
if (!check) {
return true;
}
// Otherwise, check if user has typed long enough text...
const int start = text.length();
const int end = start - check;
if (end < 0) {
return false;
}
for (int i = start - 1; i >= end; i--) {
const QChar c = text.at(i);
if (!(c.isLetter() || (c.isNumber()) || c == QLatin1Char('_'))) {
return false;
}
}
return true;
}
bool KateWordCompletionModel::shouldAbortCompletion(KTextEditor::View *view, const KTextEditor::Range &range, const QString ¤tCompletion)
{
if (m_automatic) {
KTextEditor::ViewPrivate *v = qobject_cast (view);
if (currentCompletion.length() < v->config()->wordCompletionMinimalWordLength()) {
return true;
}
}
return CodeCompletionModelControllerInterface::shouldAbortCompletion(view, range, currentCompletion);
}
void KateWordCompletionModel::completionInvoked(KTextEditor::View *view, const KTextEditor::Range &range, InvocationType it)
{
m_automatic = it == AutomaticInvocation;
saveMatches(view, range);
}
/**
* Scan throughout the entire document for possible completions,
* ignoring any dublets and words shorter than configured and/or
* reasonable minimum length.
*/
QStringList KateWordCompletionModel::allMatches(KTextEditor::View *view, const KTextEditor::Range &range) const
{
QSet result;
const int minWordSize = qMax(2, qobject_cast(view)->config()->wordCompletionMinimalWordLength());
const int lines = view->document()->lines();
for (int line = 0; line < lines; line++) {
const QString &text = view->document()->line(line);
int wordBegin = 0;
int offset = 0;
const int end = text.size();
const bool cursorLine = view->cursorPosition().line() == line;
while (offset < end) {
const QChar c = text.at(offset);
// increment offset when at line end, so we take the last character too
if ((! c.isLetterOrNumber() && c != QLatin1Char('_')) || (offset == end - 1 && offset++)) {
if (offset - wordBegin > minWordSize && (line != range.end().line() || offset != range.end().column())) {
/**
* don't add the word we are inside with cursor!
*/
if (!cursorLine || (view->cursorPosition().column() < wordBegin || view->cursorPosition().column() > offset)) {
result.insert(text.mid(wordBegin, offset - wordBegin));
}
}
wordBegin = offset + 1;
}
if (c.isSpace()) {
wordBegin = offset + 1;
}
offset += 1;
}
}
return result.values();
}
void KateWordCompletionModel::executeCompletionItem (KTextEditor::View *view
, const KTextEditor::Range &word
, const QModelIndex &index
) const
{
KTextEditor::ViewPrivate *v = qobject_cast (view);
if (v->config()->wordCompletionRemoveTail()) {
int tailStart = word.end().column();
const QString &line = view->document()->line(word.end().line());
int tailEnd = line.length();
for (int i = word.end().column(); i < tailEnd; ++i) {
// Letters, numbers and underscore are part of a word!
/// \todo Introduce configurable \e word-separators??
if (!line[i].isLetterOrNumber() && line[i] != QLatin1Char('_')) {
tailEnd = i;
}
}
int sizeDiff = m_matches.at(index.row()).size() - (word.end().column() - word.start().column());
tailStart += sizeDiff;
tailEnd += sizeDiff;
KTextEditor::Range tail(KTextEditor::Cursor(word.start().line(), tailStart), KTextEditor::Cursor(word.end().line(), tailEnd));
view->document()->replaceText(word, m_matches.at(index.row()));
v->doc()->editEnd();
v->doc()->editStart();
view->document()->replaceText(tail, QString());
} else {
view->document()->replaceText(word, m_matches.at(index.row()));
}
}
KTextEditor::CodeCompletionModelControllerInterface::MatchReaction KateWordCompletionModel::matchingItem(const QModelIndex & /*matched*/)
{
return HideListIfAutomaticInvocation;
}
bool KateWordCompletionModel::shouldHideItemsWithEqualNames() const
{
// We don't want word-completion items if the same items
// are available through more sophisticated completion models
return true;
}
// Return the range containing the word left of the cursor
KTextEditor::Range KateWordCompletionModel::completionRange(KTextEditor::View *view, const KTextEditor::Cursor &position)
{
int line = position.line();
int col = position.column();
KTextEditor::Document *doc = view->document();
while (col > 0) {
const QChar c = (doc->characterAt(KTextEditor::Cursor(line, col - 1)));
if (c.isLetterOrNumber() || c.isMark() || c == QLatin1Char('_')) {
col--;
continue;
}
break;
}
return KTextEditor::Range(KTextEditor::Cursor(line, col), position);
}
//END KateWordCompletionModel
//BEGIN KateWordCompletionView
struct KateWordCompletionViewPrivate {
KTextEditor::MovingRange *liRange; // range containing last inserted text
KTextEditor::Range dcRange; // current range to be completed by directional completion
KTextEditor::Cursor dcCursor; // directional completion search cursor
- QRegExp re; // hrm
+ QRegularExpression wordRegEx;
int directionalPos; // be able to insert "" at the correct time
bool isCompleting; // true when the directional completion is doing a completion
};
KateWordCompletionView::KateWordCompletionView(KTextEditor::View *view, KActionCollection *ac)
: QObject(view),
m_view(view),
m_dWCompletionModel(KTextEditor::EditorPrivate::self()->wordCompletionModel()),
d(new KateWordCompletionViewPrivate)
{
d->isCompleting = false;
d->dcRange = KTextEditor::Range::invalid();
d->liRange = static_cast(m_view->document())->newMovingRange(KTextEditor::Range::invalid(), KTextEditor::MovingRange::DoNotExpand);
const KColorScheme &colors(KTextEditor::EditorPrivate::self()->defaultColors().view());
KTextEditor::Attribute::Ptr a = KTextEditor::Attribute::Ptr(new KTextEditor::Attribute());
a->setBackground(colors.background(KColorScheme::ActiveBackground));
a->setForeground(colors.foreground(KColorScheme::ActiveText)); // ### this does 0
d->liRange->setAttribute(a);
QAction *action;
if (qobject_cast(view)) {
action = new QAction(i18n("Shell Completion"), this);
ac->addAction(QStringLiteral("doccomplete_sh"), action);
connect(action, SIGNAL(triggered()), this, SLOT(shellComplete()));
}
action = new QAction(i18n("Reuse Word Above"), this);
ac->addAction(QStringLiteral("doccomplete_bw"), action);
ac->setDefaultShortcut(action, Qt::CTRL + Qt::Key_8);
connect(action, SIGNAL(triggered()), this, SLOT(completeBackwards()));
action = new QAction(i18n("Reuse Word Below"), this);
ac->addAction(QStringLiteral("doccomplete_fw"), action);
ac->setDefaultShortcut(action, Qt::CTRL + Qt::Key_9);
connect(action, SIGNAL(triggered()), this, SLOT(completeForwards()));
}
KateWordCompletionView::~KateWordCompletionView()
{
delete d;
}
void KateWordCompletionView::completeBackwards()
{
complete(false);
}
void KateWordCompletionView::completeForwards()
{
complete();
}
// Pop up the editors completion list if applicable
void KateWordCompletionView::popupCompletionList()
{
qCDebug(LOG_KTE) << "entered ...";
KTextEditor::Range r = range();
KTextEditor::CodeCompletionInterface *cci = qobject_cast(m_view);
if (!cci || cci->isCompletionActive()) {
return;
}
m_dWCompletionModel->saveMatches(m_view, r);
qCDebug(LOG_KTE) << "after save matches ...";
if (! m_dWCompletionModel->rowCount(QModelIndex())) {
return;
}
cci->startCompletion(r, m_dWCompletionModel);
}
// Contributed by
void KateWordCompletionView::shellComplete()
{
KTextEditor::Range r = range();
QStringList matches = m_dWCompletionModel->allMatches(m_view, r);
if (matches.size() == 0) {
return;
}
QString partial = findLongestUnique(matches, r.columnWidth());
if (partial.isEmpty()) {
popupCompletionList();
}
else {
m_view->document()->insertText(r.end(), partial.mid(r.columnWidth()));
d->liRange->setView(m_view);
d->liRange->setRange(KTextEditor::Range(r.end(), partial.length() - r.columnWidth()));
connect(m_view, SIGNAL(cursorPositionChanged(KTextEditor::View*,KTextEditor::Cursor)), this, SLOT(slotCursorMoved()));
}
}
// Do one completion, searching in the desired direction,
// if possible
void KateWordCompletionView::complete(bool fw)
{
KTextEditor::Range r = range();
int inc = fw ? 1 : -1;
KTextEditor::Document *doc = m_view->document();
if (d->dcRange.isValid()) {
//qCDebug(LOG_KTE)<<"CONTINUE "<dcRange;
// this is a repeted activation
// if we are back to where we started, reset.
if ((fw && d->directionalPos == -1) ||
(!fw && d->directionalPos == 1)) {
const int spansColumns = d->liRange->end().column() - d->liRange->start().column();
if (spansColumns > 0) {
doc->removeText(*d->liRange);
}
d->liRange->setRange(KTextEditor::Range::invalid());
d->dcCursor = r.end();
d->directionalPos = 0;
return;
}
if (fw) {
const int spansColumns = d->liRange->end().column() - d->liRange->start().column();
d->dcCursor.setColumn(d->dcCursor.column() + spansColumns);
}
d->directionalPos += inc;
} else { // new completion, reset all
//qCDebug(LOG_KTE)<<"RESET FOR NEW";
d->dcRange = r;
d->liRange->setRange(KTextEditor::Range::invalid());
d->dcCursor = r.start();
d->directionalPos = inc;
d->liRange->setView(m_view);
connect(m_view, SIGNAL(cursorPositionChanged(KTextEditor::View*,KTextEditor::Cursor)), this, SLOT(slotCursorMoved()));
}
- d->re.setPattern(QLatin1String("\\b") + doc->text(d->dcRange) + QLatin1String("(\\w+)"));
+ d->wordRegEx.setPattern(QLatin1String("\\b") + doc->text(d->dcRange) + QLatin1String("(\\w+)"));
int pos(0);
QString ln = doc->line(d->dcCursor.line());
while (true) {
- //qCDebug(LOG_KTE)<<"SEARCHING FOR "<re.pattern()<<" "<dcCursor;
- pos = fw ?
- d->re.indexIn(ln, d->dcCursor.column()) :
- d->re.lastIndexIn(ln, d->dcCursor.column());
+ //qCDebug(LOG_KTE)<<"SEARCHING FOR "<wordRegEx.pattern()<<" "<dcCursor;
+ QRegularExpressionMatch match;
+ pos = fw ? ln.indexOf(d->wordRegEx, d->dcCursor.column(), &match)
+ : ln.lastIndexOf(d->wordRegEx, d->dcCursor.column(), &match);
- if (pos > -1) { // we matched a word
+ if (match.hasMatch()) { // we matched a word
//qCDebug(LOG_KTE)<<"USABLE MATCH";
- QString m = d->re.cap(1);
+ const QStringRef m = match.capturedRef(1);
if (m != doc->text(*d->liRange) && (d->dcCursor.line() != d->dcRange.start().line() || pos != d->dcRange.start().column())) {
// we got good a match! replace text and return.
d->isCompleting = true;
KTextEditor::Range replaceRange(d->liRange->toRange());
if (!replaceRange.isValid()) {
replaceRange.setRange(r.end(), r.end());
}
- doc->replaceText(replaceRange, m);
+ doc->replaceText(replaceRange, m.toString());
d->liRange->setRange(KTextEditor::Range(d->dcRange.end(), m.length()));
d->dcCursor.setColumn(pos); // for next try
d->isCompleting = false;
return;
}
// equal to last one, continue
else {
//qCDebug(LOG_KTE)<<"SKIPPING, EQUAL MATCH";
d->dcCursor.setColumn(pos); // for next try
if (fw) {
d->dcCursor.setColumn(pos + m.length());
}
else {
if (pos == 0) {
if (d->dcCursor.line() > 0) {
int l = d->dcCursor.line() + inc;
ln = doc->line(l);
d->dcCursor.setPosition(l, ln.length());
} else {
return;
}
}
else {
d->dcCursor.setColumn(d->dcCursor.column() - 1);
}
}
}
}
else { // no match
//qCDebug(LOG_KTE)<<"NO MATCH";
if ((! fw && d->dcCursor.line() == 0) || (fw && d->dcCursor.line() >= doc->lines())) {
return;
}
int l = d->dcCursor.line() + inc;
ln = doc->line(l);
d->dcCursor.setPosition(l, fw ? 0 : ln.length());
}
} // while true
}
void KateWordCompletionView::slotCursorMoved()
{
if (d->isCompleting) {
return;
}
d->dcRange = KTextEditor::Range::invalid();
disconnect(m_view, SIGNAL(cursorPositionChanged(KTextEditor::View*,KTextEditor::Cursor)), this, SLOT(slotCursorMoved()));
d->liRange->setView(nullptr);
d->liRange->setRange(KTextEditor::Range::invalid());
}
// Contributed by FIXME
QString KateWordCompletionView::findLongestUnique(const QStringList &matches, int lead) const
{
QString partial = matches.first();
foreach (const QString ¤t, matches) {
if (!current.startsWith(partial)) {
while (partial.length() > lead) {
partial.remove(partial.length() - 1, 1);
if (current.startsWith(partial)) {
break;
}
}
if (partial.length() == lead) {
return QString();
}
}
}
return partial;
}
// Return the string to complete (the letters behind the cursor)
QString KateWordCompletionView::word() const
{
return m_view->document()->text(range());
}
// Return the range containing the word behind the cursor
KTextEditor::Range KateWordCompletionView::range() const
{
return m_dWCompletionModel->completionRange(m_view, m_view->cursorPosition());
}
//END
diff --git a/src/data/ktexteditor.desktop b/src/data/ktexteditor.desktop
index f8e7cfff..f5eef4f0 100644
--- a/src/data/ktexteditor.desktop
+++ b/src/data/ktexteditor.desktop
@@ -1,60 +1,60 @@
[Desktop Entry]
Type=ServiceType
X-KDE-ServiceType=KTextEditor/Document
X-KDE-Derived=KParts/ReadWritePart
Comment=Embeddable Text Editor Component (with Doc/View Separation)
Comment[ar]=مكوّن محرّر نصوص يمكن تضمينه (يفصل بين Doc والمناظير)
Comment[ast]=Componente d'editor empotrable de testu (con separtación de documentos/vista)
Comment[bg]=Текстов редактор (с разделение между Doc/View)
Comment[bs]=Ugradiva komponenta uređivača teksta (s razdvajanjem dokumenta i pogleda)
Comment[ca]=Component incrustable de l'editor de text (amb separació Doc/Vista)
Comment[ca@valencia]=Component incrustable de l'editor de text (amb separació Doc/Vista)
Comment[cs]=Pohltitelná komponenta textového editoru (s oddělením Doc/View)
Comment[da]=Teksteditorkomponent som kan indlejres (med dok./visning-adskillelse)
Comment[de]=Einbettungsfähige Editorkomponente (mit Text/Ansicht-Aufteilung)
Comment[el]=Ενσωματώσιμο συστατικό επεξεργαστή κειμένου (με διαχωρισμό των δεδομένων από την προβολή τους)
Comment[en_GB]=Embeddable Text Editor Component (with Doc/View Separation)
Comment[es]=Componente empotrable de edición de texto (con separación documentos/vista)
Comment[et]=Põimitav tekstiredaktori komponent (dokumendi/vaate eraldamisega)
Comment[eu]=Testu-editore osagai txertagarria (dokumentu/ikuspegi banaketarekin)
Comment[fi]=Upotettava tekstimuokkauskomponentti (Tiedosto/Näkymä-jaolla)
Comment[fr]=Composant intégrable d'édition de texte (avec séparation Doc / Vue)
Comment[ga]=Comhpháirt eagarthóireacht téacs inleabaithe (le deighilt idir cáipéis agus amharc)
Comment[gd]=Co-phàirt deasaiche teacsa a ghabhas leabachadh (le sgaradh eadar modh deasachaidh is seallaidh)
Comment[gl]=Compoñente integrábel de edición de texto (cunha Separación Doc/Vista)
Comment[hu]=Beágyazható szövegszerkesztő (dokumentum/nézet modellel)
Comment[ia]=Componente del editor interne de texto (con separation Doc/Vista)
Comment[is]=Ívafin textaritilseining (með skjal/sýn aðskilnaði)
Comment[it]=Componente editor di testo integrabile (con separazione documento/vista)
Comment[kk]=Ендірілетін мәтін өңдеу компоненті (Құжат/көрініс үлгіні қолдайтын)
Comment[km]=សមាសភាគកម្មវិធីនិពន្ធអត្ថបទដែលអាចបង្កប់បាន (ជាមួយការបំបែក Doc/View )
-Comment[ko]=끼워넣을 수 있는 텍스트 편집기 구성 요소 (문서/뷰 구분)
+Comment[ko]=끼워넣을 수 있는 텍스트 편집기 구성 요소(문서/뷰 구분)
Comment[lt]=Įtraukiamas tekstų redagavimo komponentas (su dokumento/žiūrėjimo atskyrimu)
Comment[lv]=Iegultā teksta redaktora komponente (ar redaktora/skatītāja atdalīšanu)
Comment[mr]=अंतर्भूतयोग्य पाठ्य संपादक घटक (Doc/View विभाजनासकट)
Comment[nb]=Innebygget skriveprogram-komponent (med Doc/View-skille)
Comment[nds]=Inbettbor Texteditor-Komponent (mit Dokment-/Ansicht-Trennen)
Comment[nl]=Ingebed tekstinvoercomponent (met scheiding van tekst/weergave)
Comment[nn]=Innebyggbar skriveprogramkomponent (med Doc/View-skilje)
Comment[pa]=ਇੰਬੈੱਡਯੋਗ ਟੈਕਸਟ ਐਡੀਟਰ ਭਾਗ (Doc/ਝਲਕ ਵੱਖ ਕਰਨ ਨਾਲ)
Comment[pl]=Komponent osadzanego edytora tekstu (z podziałem Dokument/Widok)
Comment[pt]=Componente Incorporado do Editor de Texto (com Separação entre Documentos)
Comment[pt_BR]=Componente de edição de textos integrado (com separação de documentação/visualização)
Comment[ro]=Componentă de Editare Text Încorporabilă (cu Separarea Documentului/Vizualizării)
Comment[ru]=Встраиваемый компонент редактора текста (с поддержкой модели документ/вид)
Comment[si]=තිළැලිය හැකි පෙළ සකසන සංරචකය (ලේඛන/දසුන් වෙන්කිරීම සහිතව)
Comment[sk]=Vložiteľný komponent textového editora (s oddelením Doc/Pohľad)
Comment[sl]=Vgradljiva enota urejevalnika besedil (z ločevanjem pogleda in dokumenta)
Comment[sr]=Угнездива компонента уређивача текста (уз раздвајање документ-приказ)
Comment[sr@ijekavian]=Угњездива компонента уређивача текста (уз раздвајање документ-приказ)
Comment[sr@ijekavianlatin]=Ugnjezdiva komponenta uređivača teksta (uz razdvajanje dokument-prikaz)
Comment[sr@latin]=Ugnezdiva komponenta uređivača teksta (uz razdvajanje dokument-prikaz)
Comment[sv]=Inbäddningsbar texteditor (med dok/vyseparation)
Comment[tg]=Қисми таҳриргари матнии дарунсохтшаванда (бо тақсимкунии Санад/Намоиш)
Comment[tr]=Gömülebilir Metin Düzenleyici Bileşeni (Doc/View ayrımı ile)
Comment[ug]=سىڭدۈرۈشچان تېكىست تەھرىرلىگۈچ بۆلىكى(پۈتۈك/كۆرۈنۈش ئايرىلىدۇ)
Comment[uk]=Компонент редактора текстів, який можна вбудовувати (з розділенням документ/вигляд)
Comment[wa]=Ravalé compôzant aspougneu d' tecse (avou dispårtaedje documint/vuwe)
Comment[x-test]=xxEmbeddable Text Editor Component (with Doc/View Separation)xx
Comment[zh_CN]=可嵌入的文本编辑器部件(文档和视图分离)
Comment[zh_TW]=可嵌入的文字編輯器元件 (Doc/View 分開)
diff --git a/src/dialogs/katedialogs.cpp b/src/dialogs/katedialogs.cpp
index 211ba4a4..28468627 100644
--- a/src/dialogs/katedialogs.cpp
+++ b/src/dialogs/katedialogs.cpp
@@ -1,1462 +1,1462 @@
/* This file is part of the KDE libraries
Copyright (C) 2002, 2003 Anders Lund
Copyright (C) 2003 Christoph Cullmann
Copyright (C) 2001 Joseph Wenninger
Copyright (C) 2006 Dominik Haumann
Copyright (C) 2007 Mirko Stocker
Copyright (C) 2009 Michel Ludwig
Copyright (C) 2009 Erlend Hamberg
Based on work of:
Copyright (C) 1999 Jochen Wilhelmy
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
//BEGIN Includes
#include "katedialogs.h"
#include
#include
#include "kateautoindent.h"
#include "katebuffer.h"
#include "kateconfig.h"
#include "katedocument.h"
#include "kateglobal.h"
#include "kateschema.h"
#include "katemodeconfigpage.h"
#include "kateview.h"
#include "spellcheck/spellcheck.h"
#include "kateglobal.h"
// auto generated ui files
#include "ui_textareaappearanceconfigwidget.h"
#include "ui_bordersappearanceconfigwidget.h"
#include "ui_navigationconfigwidget.h"
#include "ui_editconfigwidget.h"
#include "ui_indentationconfigwidget.h"
#include "ui_completionconfigtab.h"
#include "ui_opensaveconfigwidget.h"
#include "ui_opensaveconfigadvwidget.h"
#include "ui_spellcheckconfigwidget.h"
#include
#include
#include
#include
#include
#include
#include "katepartdebug.h"
#include "kateabstractinputmodefactory.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include