From eedac700b10ab9e5900708ff06a09e881317f6eb Mon Sep 17 00:00:00 2001 From: "B. Stack" Date: Tue, 5 Apr 2022 14:00:15 -0400 Subject: scite: add devuan dpkg --- scite/stackrpms-2022-04-05.diff | 539 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 539 insertions(+) create mode 100644 scite/stackrpms-2022-04-05.diff (limited to 'scite/stackrpms-2022-04-05.diff') diff --git a/scite/stackrpms-2022-04-05.diff b/scite/stackrpms-2022-04-05.diff new file mode 100644 index 0000000..e25c61d --- /dev/null +++ b/scite/stackrpms-2022-04-05.diff @@ -0,0 +1,539 @@ +diff -x '.*.swp' -Naur scite.salsa/debian/changelog stackrpms/scite/debian/changelog +--- scite.salsa/debian/changelog 2022-04-05 09:49:25.955774896 -0400 ++++ stackrpms/scite/debian/changelog 2022-04-04 19:51:15.109951844 -0400 +@@ -1,3 +1,10 @@ ++scite (5.2.2-1+devuan) obs; urgency=medium ++ ++ * Add emitUnicode lua script, Ctrl+U ++ * Use lua 5.4.4 ++ ++ -- B. Stack Mon, 04 Apr 2022 09:51:24 -0400 ++ + scite (5.2.2-1) unstable; urgency=medium + + * New upstream version 5.2.2 +diff -x '.*.swp' -Naur scite.salsa/debian/control stackrpms/scite/debian/control +--- scite.salsa/debian/control 2022-04-05 09:49:25.955774896 -0400 ++++ stackrpms/scite/debian/control 2022-04-05 08:32:40.007194419 -0400 +@@ -1,14 +1,13 @@ + Source: scite +-Maintainer: Michael Vogt +-Uploaders: Antonio Valentino , +- Andreas Rönnquist ++Maintainer: B. Stack ++XSBC-Original-Maintainer: Michael Vogt + Section: editors + Priority: optional + Rules-Requires-Root: no + Build-Depends: debhelper-compat (= 13), + libgtk-3-dev, + libglib2.0-dev, +- liblua5.3-dev ++ liblua5.4-dev + Standards-Version: 4.6.0.1 + Vcs-Browser: https://salsa.debian.org/debian/scite + Vcs-Git: https://salsa.debian.org/debian/scite.git +diff -x '.*.swp' -Naur scite.salsa/debian/emitUnicode.lua stackrpms/scite/debian/emitUnicode.lua +--- scite.salsa/debian/emitUnicode.lua 1969-12-31 19:00:00.000000000 -0500 ++++ stackrpms/scite/debian/emitUnicode.lua 2022-04-04 19:08:15.295488065 -0400 +@@ -0,0 +1,247 @@ ++-- DESCRIPTION: ++-- Unicode hexadecimal table: https://example.com/copied/unicode.html ++-- Source: http://lua-users.org/wiki/SciteUnicodeInput http://sourceforge.net/projects/emitunicodeinscite/ ++-- Future reference: http://lua-users.org/wiki/SciteScripts ++-- ++-- This lua script adds utf8 unicode input, to the scite text editor. ++-- ++-- The scite text editor should be set to use the UTF-8 encoding ++-- , because this script adds utf8, into the text buffer of the ++-- scite editor. Select File->Encoding->UTF-8, from the ++-- menu bar of scite. ++-- ++-- For example, it will be possible that you type 2200 CTRL+U ++-- , and 2200 is replaced to ∀; (U+2200), in the scite editor. ++-- ++-- ______________________________________________________________________________ ++-- ++-- INSTALL: ++-- ++-- To have scite running this script each time you press Ctrl+U, add next lines ++-- into your ~/SciTEUser.properties file, where ~ is your home directory. ++-- FILE ~/SciTEUser.properties: ++--[[ ++ext.lua.startup.script=$(SciteUserHome)/emitUtf8UnicodeIntoTheSciteEditor.lua ++command.name.8.*=Emit UTF8 Unicode ++command.subsystem.8.*=3 ++command.8.*=emitUtf8UnicodeIntoTheSciteEditor ++command.mode.8.*=savebefore:no ++command.shortcut.8.*=Ctrl+U ++--]] ++-- ______________________________________________________________________________ ++-- THE LUA CODE: ++-- ++-- Next is the definition of the lua function that is called by scite ++-- when CTRL+U is pressed, to replace unicode endpoint encoding, with ++-- utf8 encoding of the unicode endpoint. ++-- ______________________________________________________________________________ ++ ++ ++-- Computes the utf8 encoding for a unicode codepoint u ++-- , when 0 <= u <= 0x7f ++-- ++-- @param unicodeValue the unicode codepoint u ++-- ++-- @return the utf8 encoding of the unicode codepoint u ++function case1UnicodeToUtf8(unicodeValue) ++ --print('case 1') ++ local u = unicodeValue ++ local byte0 = (u % 0x80) ++ local utf8 = string.char(byte0) ++ return utf8 ++end ++ ++-- ______________________________________________________________________________ ++-- Computes the utf8 encoding for a unicode codepoint u ++-- , when 0x80 <= u <= 0x7ff ++-- ++-- @param unicodeValue the unicode codepoint u ++-- ++-- @return the utf8 encoding of the unicode codepoint u ++function case2UnicodeToUtf8(unicodeValue) ++ --print('case 2') ++ local u = unicodeValue ++ local byte1 = (0x80 + (u % 0x40) ) ++ u = math.floor(u / 0x40) ++ local byte0 = (0xc0 + (u % 0x20) ) ++ local utf8 = string.char(byte0, byte1) ++ return utf8 ++end ++ ++-- ______________________________________________________________________________ ++-- Computes the utf8 encoding for a unicode codepoint u ++-- , when 0x800 <= u <= 0xffff. ++-- ++-- @param unicodeValue the unicode codepoint u ++-- ++-- @return the utf8 encoding of the unicode codepoint u ++function case3UnicodeToUtf8(unicodeValue) ++ local u = unicodeValue ++ local byte2 = (0x80 + (u % 0x40)) ++ -- print('byte2: '..byte2) ++ u = math.floor(u / 0x40) ++ local byte1 = (0x80 + (u % 0x40)) ++ -- print('byte1: '..byte1) ++ u = math.floor(u / 0x40) ++ local byte0 = (0xe0 + (u % 0x10)) ++ -- print('byte0: '..byte0) ++ local utf8 = string.char(byte0, byte1, byte2) ++ return utf8 ++end ++ ++-- ______________________________________________________________________________ ++-- Computes the utf8 encoding for a unicode codepoint u ++-- , when 0x10000 <= u <= 0x10ffff. ++-- ++-- @param unicodeValue the unicode codepoint u ++-- ++-- @return the utf8 encoding of the unicode codepoint u ++function case4UnicodeToUtf8(unicodeValue) ++ local u = unicodeValue ++ local byte3 = (0x80 + (u % 0x40)) ++ u = math.floor(u / 0x40) ++ local byte2 = (0x80 + (u % 0x40)) ++ u = math.floor(u / 0x40) ++ local byte1 = (0x80 + (u % 0x40)) ++ u = math.floor(u / 0x40) ++ local byte0 = (0xf0 + (u % 0x8)) ++ local utf8 = string.char(byte0, byte1, byte2, byte3) ++ return utf8 ++end ++ ++-- ______________________________________________________________________________ ++-- Converts a unicode integer value, into a utf8 string value. ++-- ++-- The unicode integer value is an integer that ++-- is greater than or equal to zero. ++-- ++-- The utf8 string value is a string that is a sequence of ++-- 8 bits characters that give the utf8 encoding of the ++-- unicode codepoint given by the unicode integer value. ++-- ++-- @param unicodeValue the unicode integer value; ++-- a unicode codepoint ++-- ++-- @return the utf8 encoding of the unicode codepoint ++-- provided by the unicodeValue input argument ++function unicodeToUtf8(unicodeValue) ++ local u = unicodeValue ++ if ((0x800 <= u) and (0xffff >= u)) ++ then ++ return case3UnicodeToUtf8(u) ++ end ++ if ((0x80 <= u) and (0x7fff >= u)) ++ then ++ return case2UnicodeToUtf8(u) ++ end ++ if ((0x0 <= u) and (0x7f >= u)) ++ then ++ return case1UnicodeToUtf8(u) ++ end ++ if( (0x10000 <= u) and (0x10ffff >= u) ) ++ then ++ return case4UnicodeToUtf8(u) ++ end ++ return nil ++end ++ ++-- ______________________________________________________________________________ ++-- Peeks (reads) the character at position i, in the Scite Editor. ++-- If the character is the ascii name of a hex digit, it returns ++-- the corresponding hex digit, otherwise it returns nil. ++-- ++-- @param i position in the Scite Editor ++-- @return hex digit at position i, or nil ++function peekHexdigit(i) ++ local e = editor ++ local asciiCode = e.CharAt[i] ++ if((0>asciiCode) or (0xff < asciiCode)) ++ then ++ return nil ++ end ++ local charValue = string.char(asciiCode) ++ local hexDigit = tonumber(charValue,0x10) ++ return hexDigit -- may be nil ++end ++ ++-- ______________________________________________________________________________ ++-- Reads the sequence of maximum length at most 5, at the left of the cursor ++-- in the Scite Editor. ++-- Encodes the longest suffix of this sequence, that is a hex number, into ++-- the utf encoding of this hex number. ++-- Replaces this longest suffix, with the utf8 sequence. ++-- ++-- @return true a suffix of length greater than zero, at most 5 existed ++-- and was replaced with the utf8 encoding of the number it ++-- represented ++-- ++-- false , when no such suffix existed ++function emitUtf8Unicode() ++ local e = editor ++ local n = e.TextLength ++ local i = e.CurrentPos ++ local maxlen = 5 ++ if ((0 == n) or (1 > i)) ++ then ++ return nil -- Success. No request ++ end ++ local len = 1 ++ local len2 = 0 ++ local u = 0 ++ local thePower = 1 ++ while ( (len <= maxlen) ++ and (0 <= (i - len) ) ++ ) ++ do ++ local hexDigit = peekHexdigit(i-len,u) ++ if (nil == hexDigit) ++ then ++ break -- out of the while loop ++ end ++ u = ( u + (thePower * hexDigit) ) ++ thePower = (0x10 * thePower ) ++ len2 = len ++ --print("u: "..u) ++ len = len + 1 ++ end ++ if (0 == len2) ++ then ++ return nil -- Failure. No unicode ++ end ++ utf8 = unicodeToUtf8(u) ++ if(nil == utf8) ++ then ++ return nil -- Failure. Unicode to utf8 conversion failed. ++ end ++ e:SetSel(i-len2,i) ++ e:ReplaceSel(utf8) ++ --print("utf8: "..utf8) ++ return true -- Success. ++end ++ ++-- ______________________________________________________________________________ ++-- Emits utf8 encoding in the place of the unicode codepoint ++-- in the editor, at the left of the cursor. ++-- ++-- Writes a message to the Output pane, if no codepoint existed ++-- at the left of the cursor. ++-- ++function emitUtf8UnicodeIntoTheSciteEditor() ++ local ok = emitUtf8Unicode() ++ if not ok ++ then ++ --print("Failed to encode unicode into text editor.") ++ end ++end ++ ++-- ______________________________________________________________________________ ++-- ++-- Following web pages were useful in writing the lua scite script. ++-- ++-- http://lua-users.org/wiki/UsingLuaWithScite ++-- http://www.scintilla.org/PaneAPI.html ++-- http://www.lua.org/manual/5.1/manual.html#pdf-tonumber ++-- https://en.wikipedia.org/wiki/UTF-8 ++-- ++-- http://lua-users.org/lists/lua-l/2007-08/msg00276.html ++-- http://keplerproject.github.io/luadoc/ +diff -x '.*.swp' -Naur scite.salsa/debian/patches/0007-Build-with-Debian-packaged-Lua.patch stackrpms/scite/debian/patches/0007-Build-with-Debian-packaged-Lua.patch +--- scite.salsa/debian/patches/0007-Build-with-Debian-packaged-Lua.patch 2022-04-05 09:49:25.955774896 -0400 ++++ stackrpms/scite/debian/patches/0007-Build-with-Debian-packaged-Lua.patch 2022-04-04 20:56:01.431094606 -0400 +@@ -33,8 +33,8 @@ + -CONFIGFLAGS:=$(shell $(PKG_CONFIG) --cflags $(GTK_VERSION)) + -CONFIGLIB:=$(shell $(PKG_CONFIG) --libs $(GTK_VERSION) gthread-2.0 gmodule-no-export-2.0) + +# For the Lua and Gnome desktop stuff to work, prefix must point to where Lua and Gnome thinks it is. +-+CONFIGFLAGS:=$(shell $(PKG_CONFIG) --cflags $(GTK_VERSION)) $(shell $(PKG_CONFIG) --cflags lua5.3) +-+CONFIGLIB:=$(shell $(PKG_CONFIG) --libs $(GTK_VERSION) gthread-2.0 gmodule-no-export-2.0) $(shell $(PKG_CONFIG) --libs lua5.3) +++CONFIGFLAGS:=$(shell $(PKG_CONFIG) --cflags $(GTK_VERSION)) $(shell $(PKG_CONFIG) --cflags lua5.4) +++CONFIGLIB:=$(shell $(PKG_CONFIG) --libs $(GTK_VERSION) gthread-2.0 gmodule-no-export-2.0) $(shell $(PKG_CONFIG) --libs lua5.4) + gnomeprefix:=$(shell $(PKG_CONFIG) --variable=prefix $(GTK_VERSION) 2>/dev/null) + ifndef prefix + ifdef gnomeprefix +diff -x '.*.swp' -Naur scite.salsa/debian/patches/add-emitUnicode.patch stackrpms/scite/debian/patches/add-emitUnicode.patch +--- scite.salsa/debian/patches/add-emitUnicode.patch 1969-12-31 19:00:00.000000000 -0500 ++++ stackrpms/scite/debian/patches/add-emitUnicode.patch 2022-04-04 19:08:15.295488065 -0400 +@@ -0,0 +1,16 @@ ++--- a/scite/src/SciTEGlobal.properties 2022-03-30 20:48:24.000000000 -0400 +++++ b/scite/src/SciTEGlobal.properties 2022-04-04 10:14:32.803893680 -0400 ++@@ -550,6 +550,13 @@ ++ # The set of imports allowed can be set with ++ #imports.include=ave ++ +++ext.lua.startup.script=$(SciteDefaultHome)/emitUnicode.lua +++command.name.8.*=Emit UTF8 Unicode +++command.subsystem.8.*=3 +++command.8.*=emitUtf8UnicodeIntoTheSciteEditor +++command.mode.8.*=savebefore:no +++command.shortcut.8.*=Ctrl+U +++ ++ # Import all the language specific properties files in this directory ++ import * ++ +diff -x '.*.swp' -Naur scite.salsa/debian/patches/series stackrpms/scite/debian/patches/series +--- scite.salsa/debian/patches/series 2022-04-05 09:49:25.955774896 -0400 ++++ stackrpms/scite/debian/patches/series 2022-04-04 22:12:35.852188087 -0400 +@@ -2,3 +2,5 @@ + 0003-reproducible_build.patch + 0005-scite-desktop.patch + 0007-Build-with-Debian-packaged-Lua.patch ++use-lua5.4.4.patch ++add-emitUnicode.patch +diff -x '.*.swp' -Naur scite.salsa/debian/patches/use-lua5.4.4.patch stackrpms/scite/debian/patches/use-lua5.4.4.patch +--- scite.salsa/debian/patches/use-lua5.4.4.patch 1969-12-31 19:00:00.000000000 -0500 ++++ stackrpms/scite/debian/patches/use-lua5.4.4.patch 2022-04-04 19:15:01.427643169 -0400 +@@ -0,0 +1,187 @@ ++Name: Patch scite to use distro package of lua, Devuan ++Version: 5.2.2 ++Lua Version: 5.4.4 ++Author: bgstack15@gmail.com ++Date: 2022-04-04 ++diff -aur scite/gtk/deps.mak scite/gtk/deps.mak ++--- a/scite/gtk/deps.mak 2022-03-30 20:48:24.000000000 -0400 +++++ b/scite/gtk/deps.mak 2022-04-04 14:47:39.110529717 -0400 ++@@ -469,13 +469,6 @@ ++ ../lua/src/luaconf.h \ ++ ../lua/src/lauxlib.h \ ++ ../lua/src/lualib.h ++-lbitlib.o: \ ++- ../lua/src/lbitlib.c \ ++- ../lua/src/lprefix.h \ ++- ../lua/src/lua.h \ ++- ../lua/src/luaconf.h \ ++- ../lua/src/lauxlib.h \ ++- ../lua/src/lualib.h ++ lcode.o: \ ++ ../lua/src/lcode.c \ ++ ../lua/src/lprefix.h \ ++diff -aur scite/src/LuaExtension.cxx scite/src/LuaExtension.cxx ++--- a/scite/src/LuaExtension.cxx 2022-03-30 20:48:24.000000000 -0400 +++++ b/scite/src/LuaExtension.cxx 2022-04-04 14:46:35.097978533 -0400 ++@@ -237,7 +237,7 @@ ++ ++ const int paneIndex = lua_upvalueindex(1); ++ check_pane_object(L, paneIndex); ++- const int message = luaL_checkint(L, 1); +++ const int message = luaL_checkinteger(L, 1); ++ ++ lua_pushvalue(L, paneIndex); ++ lua_replace(L, 1); ++@@ -276,7 +276,7 @@ ++ } ++ ++ static int cf_scite_constname(lua_State *L) { ++- const int message = luaL_checkint(L, 1); +++ const int message = luaL_checkinteger(L, 1); ++ const char *prefix = luaL_optstring(L, 2, nullptr); ++ const std::string constName = IFaceTable::GetConstantName(message, prefix); ++ if (constName.length() > 0) { ++@@ -307,7 +307,7 @@ ++ } ++ ++ static int cf_scite_menu_command(lua_State *L) { ++- const int cmdID = luaL_checkint(L, 1); +++ const int cmdID = luaL_checkinteger(L, 1); ++ if (cmdID) { ++ host->DoMenuCommand(cmdID); ++ } ++@@ -329,7 +329,7 @@ ++ } ++ ++ static int cf_scite_strip_set(lua_State *L) { ++- const int control = luaL_checkint(L, 1); +++ const int control = luaL_checkinteger(L, 1); ++ const char *value = luaL_checkstring(L, 2); ++ if (value) { ++ host->UserStripSet(control, value); ++@@ -338,7 +338,7 @@ ++ } ++ ++ static int cf_scite_strip_set_list(lua_State *L) { ++- const int control = luaL_checkint(L, 1); +++ const int control = luaL_checkinteger(L, 1); ++ const char *value = luaL_checkstring(L, 2); ++ if (value) { ++ host->UserStripSetList(control, value); ++@@ -347,7 +347,7 @@ ++ } ++ ++ static int cf_scite_strip_value(lua_State *L) { ++- const int control = luaL_checkint(L, 1); +++ const int control = luaL_checkinteger(L, 1); ++ std::string value = host->UserStripValue(control); ++ push_string(L, value); ++ return 1; ++@@ -437,7 +437,7 @@ ++ SA::Position rangeStart = 0; ++ SA::Position rangeEnd = 0; ++ ++- const int flags = (nArgs > 2) ? luaL_checkint(L, 3) : 0; +++ const int flags = (nArgs > 2) ? luaL_checkinteger(L, 3) : 0; ++ hasError = (flags == 0 && lua_gettop(L) > nArgs); ++ ++ if (!hasError) { ++@@ -514,7 +514,7 @@ ++ ++ SA::ScintillaCall &sc = host->PaneCaller(pmo->pane); ++ sc.SetTarget(pmo->range); ++- sc.ReplaceTarget(lua_strlen(L, 2), replacement); +++ sc.ReplaceTarget(lua_rawlen(L, 2), replacement); ++ pmo->range.end = sc.TargetEnd(); ++ return 0; ++ } ++@@ -600,7 +600,7 @@ ++ pmo->endPosOrig = 0; ++ pmo->flags = 0; ++ if (nargs >= 3) { ++- pmo->flags = luaL_checkint(L, 3); +++ pmo->flags = luaL_checkinteger(L, 3); ++ if (nargs >= 4) { ++ pmo->range.end = pmo->endPosOrig = luaL_checkinteger(L, 4); ++ if (pmo->range.end < 0) { ++@@ -765,7 +765,7 @@ ++ const int nargs = lua_gettop(L); ++ const char *code = luaL_checkstring(L, 1); ++ const char *name = luaL_optstring(L, 2, code); ++- if (0 == luaL_loadbuffer(L, code, lua_strlen(L, 1), name)) { +++ if (0 == luaL_loadbuffer(L, code, lua_rawlen(L, 1), name)) { ++ lua_call(L, 0, LUA_MULTRET); ++ return lua_gettop(L) - nargs; ++ } else { ++@@ -896,7 +896,7 @@ ++ int loopParamCount = 2; ++ ++ if (func.paramType[0] == iface_length && func.paramType[1] == iface_string) { ++- params[0] = lua_strlen(L, arg); +++ params[0] = lua_rawlen(L, arg); ++ params[1] = SptrFromString(params[0] ? lua_tostring(L, arg) : ""); ++ loopParamCount = 0; ++ } else if ((func.paramType[1] == iface_stringresult) || (func.returnType == iface_stringresult)) { ++@@ -915,8 +915,8 @@ ++ const char *s = lua_tostring(L, arg++); ++ params[i] = SptrFromString(s ? s : ""); ++ } else if (func.paramType[i] == iface_keymod) { ++- const int keycode = luaL_checkint(L, arg++) & 0xFFFF; ++- const int modifiers = luaL_checkint(L, arg++) & +++ const int keycode = luaL_checkinteger(L, arg++) & 0xFFFF; +++ const int modifiers = luaL_checkinteger(L, arg++) & ++ static_cast(SA::KeyMod::Shift|SA::KeyMod::Ctrl|SA::KeyMod::Alt); ++ params[i] = keycode | (modifiers<<16); ++ } else if (func.paramType[i] == iface_bool) { ++@@ -1805,7 +1805,7 @@ ++ static int SetLevelAt(lua_State *L) { ++ StylingContext *context = Context(L); ++ const SA::Line line = luaL_checkinteger(L, 2); ++- const int level = luaL_checkint(L, 3); +++ const int level = luaL_checkinteger(L, 3); ++ context->styler->SetLevel(line, static_cast(level)); ++ return 0; ++ } ++@@ -1820,7 +1820,7 @@ ++ static int SetLineState(lua_State *L) { ++ StylingContext *context = Context(L); ++ const SA::Line line = luaL_checkinteger(L, 2); ++- const int stateOfLine = luaL_checkint(L, 3); +++ const int stateOfLine = luaL_checkinteger(L, 3); ++ context->styler->SetLineState(line, stateOfLine); ++ return 0; ++ } ++@@ -1898,7 +1898,7 @@ ++ StylingContext *context = Context(L); ++ const SA::Position startPosStyle = luaL_checkinteger(L, 2); ++ const SA::Position lengthStyle = luaL_checkinteger(L, 3); ++- const int initialStyle = luaL_checkint(L, 4); +++ const int initialStyle = luaL_checkinteger(L, 4); ++ context->StartStyling(startPosStyle, lengthStyle, initialStyle); ++ return 0; ++ } ++@@ -1957,7 +1957,7 @@ ++ static int SetState(lua_State *L) { ++ StylingContext *context = Context(L); ++ context->Colourize(); ++- context->state = luaL_checkint(L, 2); +++ context->state = luaL_checkinteger(L, 2); ++ return 0; ++ } ++ ++@@ -1965,13 +1965,13 @@ ++ StylingContext *context = Context(L); ++ context->Forward(); ++ context->Colourize(); ++- context->state = luaL_checkint(L, 2); +++ context->state = luaL_checkinteger(L, 2); ++ return 0; ++ } ++ ++ static int ChangeState(lua_State *L) { ++ StylingContext *context = Context(L); ++- context->state = luaL_checkint(L, 2); +++ context->state = luaL_checkinteger(L, 2); ++ return 0; ++ } ++ +diff -x '.*.swp' -Naur scite.salsa/debian/rules stackrpms/scite/debian/rules +--- scite.salsa/debian/rules 2022-04-05 09:49:25.955774896 -0400 ++++ stackrpms/scite/debian/rules 2022-04-05 10:24:05.582048509 -0400 +@@ -1,6 +1,7 @@ + #!/usr/bin/make -f + + export DEB_BUILD_MAINT_OPTIONS=hardening=+all ++export DEB_BUILD_OPTIONS=noautodbgsym + + include /usr/share/dpkg/pkg-info.mk + BUILD_DATE ?= $(shell date --utc --date="@$(SOURCE_DATE_EPOCH)" "+%b %d %Y %T") +@@ -43,6 +44,7 @@ + mv -f $(CURDIR)/debian/scite/usr/share/scite/*.txt $(CURDIR)/debian/scite/usr/share/doc/scite/ + mv -f $(CURDIR)/debian/scite/usr/share/scite/*.jpg $(CURDIR)/debian/scite/usr/share/doc/scite/ + mv -f $(CURDIR)/debian/scite/usr/share/scite/*.png $(CURDIR)/debian/scite/usr/share/doc/scite/ ++ cp -p debian/emitUnicode.lua $(CURDIR)/debian/scite/usr/share/scite/ + for f in $(CURDIR)/debian/scite/usr/share/doc/scite/*.html; do \ + dh_link usr/share/doc/scite/$$(basename $$f) usr/share/scite/$$(basename $$f); \ + done -- cgit