|
|
|
@ -285,7 +285,7 @@ class _shareTemplate(object):
|
|
|
|
_deltVarEnd = len(varEnd)
|
|
|
|
_deltVarEnd = len(varEnd)
|
|
|
|
objVar = None
|
|
|
|
objVar = None
|
|
|
|
_reVar = re.compile(
|
|
|
|
_reVar = re.compile(
|
|
|
|
"%s(?:[a-z0-9_]+\.)?[a-zA-Z0-9_-]+%s" % (varStart, varEnd), re.M)
|
|
|
|
r"%s(?:[a-z0-9_]+\.)?[a-zA-Z0-9_-]+%s" % (varStart, varEnd), re.M)
|
|
|
|
|
|
|
|
|
|
|
|
def applyVarsTemplate(self, textTemplate, nameTemplate):
|
|
|
|
def applyVarsTemplate(self, textTemplate, nameTemplate):
|
|
|
|
""" Заменяет переменные на их значения
|
|
|
|
""" Заменяет переменные на их значения
|
|
|
|
@ -346,11 +346,11 @@ class _shareTermsFunction(object):
|
|
|
|
"""Общие аттрибуты для классов _terms и templateFunctions"""
|
|
|
|
"""Общие аттрибуты для классов _terms и templateFunctions"""
|
|
|
|
# Символы допустимые в скобках функции шаблона
|
|
|
|
# Символы допустимые в скобках функции шаблона
|
|
|
|
_reFunctionArgvInSquareBrackets = (
|
|
|
|
_reFunctionArgvInSquareBrackets = (
|
|
|
|
"a-zA-Z0-9_:;%@<>=\!\|\{\}\^\$\?\(\)\[\]\-"
|
|
|
|
r"a-zA-Z0-9_:;%@<>=\!\|\{\}\^\$\?\(\)\[\]\-"
|
|
|
|
"\n\+\,\*\/\.\'\"~\\\\ ")
|
|
|
|
r"\n\+\,\*\/\.\'\"~\\\\ ")
|
|
|
|
_reFunctionArgvText = "[%s]" % _reFunctionArgvInSquareBrackets
|
|
|
|
_reFunctionArgvText = r"[%s]" % _reFunctionArgvInSquareBrackets
|
|
|
|
# регулярное выражение для поиска функции в шаблоне
|
|
|
|
# регулярное выражение для поиска функции в шаблоне
|
|
|
|
_reFunctionText = ("([a-zA-Z0-9\_-]+)\(((?:#-|-#|%s)+|)\)" %
|
|
|
|
_reFunctionText = (r"([a-zA-Z0-9\_-]+)\(((?:#-|-#|%s)+|)\)" %
|
|
|
|
_reFunctionArgvText)
|
|
|
|
_reFunctionArgvText)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@ -361,15 +361,15 @@ class _terms(_error, _shareTermsFunction, _shareTemplate):
|
|
|
|
# регулярное выражение для поиска функции в шаблоне
|
|
|
|
# регулярное выражение для поиска функции в шаблоне
|
|
|
|
_reFunction = re.compile(_shareTermsFunction._reFunctionText)
|
|
|
|
_reFunction = re.compile(_shareTermsFunction._reFunctionText)
|
|
|
|
# регулярное выражение для не версии
|
|
|
|
# регулярное выражение для не версии
|
|
|
|
_re_not_Version = re.compile("[^0-9\.]")
|
|
|
|
_re_not_Version = re.compile(r"[^0-9\.]")
|
|
|
|
# регулярное выражение не номер
|
|
|
|
# регулярное выражение не номер
|
|
|
|
_re_not_Number = re.compile("[^0-9]")
|
|
|
|
_re_not_Number = re.compile(r"[^0-9]")
|
|
|
|
_suffixDict = {"pre": -2, "p": 0, "alpha": -4, "beta": -3, "rc": -1}
|
|
|
|
_suffixDict = {"pre": -2, "p": 0, "alpha": -4, "beta": -3, "rc": -1}
|
|
|
|
_lenSuffixDict = len(_suffixDict)
|
|
|
|
_lenSuffixDict = len(_suffixDict)
|
|
|
|
# Регулярное выражение для названия переменной
|
|
|
|
# Регулярное выражение для названия переменной
|
|
|
|
_reRightName = re.compile("^(?:[a-z_\-]+\.)?(?:[a-zA-Z0-9_\-]+)$")
|
|
|
|
_reRightName = re.compile(r"^(?:[a-z_\-]+\.)?(?:[a-zA-Z0-9_\-]+)$")
|
|
|
|
# Регулярное выражение для сравниваемого значения
|
|
|
|
# Регулярное выражение для сравниваемого значения
|
|
|
|
_reDenyValue = re.compile("[^0-9a-zA-Z_/\.,-]")
|
|
|
|
_reDenyValue = re.compile(r"[^0-9a-zA-Z_/\.,-]")
|
|
|
|
# латинские буквы в нижнем регистре
|
|
|
|
# латинские буквы в нижнем регистре
|
|
|
|
_letters = list(string.ascii_lowercase)
|
|
|
|
_letters = list(string.ascii_lowercase)
|
|
|
|
|
|
|
|
|
|
|
|
@ -620,7 +620,7 @@ class _terms(_error, _shareTermsFunction, _shareTemplate):
|
|
|
|
self.setError(textError)
|
|
|
|
self.setError(textError)
|
|
|
|
return False
|
|
|
|
return False
|
|
|
|
if "load" == searchFunct.group(1) and \
|
|
|
|
if "load" == searchFunct.group(1) and \
|
|
|
|
re.search("\(\s*num\s*,", vals[0]):
|
|
|
|
re.search(r"\(\s*num\s*,", vals[0]):
|
|
|
|
if valVars:
|
|
|
|
if valVars:
|
|
|
|
try:
|
|
|
|
try:
|
|
|
|
valVars = int(valVars)
|
|
|
|
valVars = int(valVars)
|
|
|
|
@ -694,7 +694,7 @@ class _terms(_error, _shareTermsFunction, _shareTemplate):
|
|
|
|
("pkg", "merge", "mergepkg")) or
|
|
|
|
("pkg", "merge", "mergepkg")) or
|
|
|
|
(flagFunction and searchFunct.group(
|
|
|
|
(flagFunction and searchFunct.group(
|
|
|
|
1) == "load" and
|
|
|
|
1) == "load" and
|
|
|
|
re.search("\(\s*ver\s*,",
|
|
|
|
re.search(r"\(\s*ver\s*,",
|
|
|
|
vals[0]))):
|
|
|
|
vals[0]))):
|
|
|
|
# Проверка значения на версию (или интервал)
|
|
|
|
# Проверка значения на версию (или интервал)
|
|
|
|
if (not self._isVersion(vals[1]) and
|
|
|
|
if (not self._isVersion(vals[1]) and
|
|
|
|
@ -819,7 +819,7 @@ class _terms(_error, _shareTermsFunction, _shareTemplate):
|
|
|
|
return not flagQ, filter(lambda x: not x in foundPar,
|
|
|
|
return not flagQ, filter(lambda x: not x in foundPar,
|
|
|
|
mass), foundPar
|
|
|
|
mass), foundPar
|
|
|
|
|
|
|
|
|
|
|
|
listPar = re.split("\s+", linePar)
|
|
|
|
listPar = re.split(r"\s+", linePar)
|
|
|
|
flagFoundQ = "'" in linePar
|
|
|
|
flagFoundQ = "'" in linePar
|
|
|
|
flagFoundQQ = '"' in linePar
|
|
|
|
flagFoundQQ = '"' in linePar
|
|
|
|
if flagFoundQ and flagFoundQQ:
|
|
|
|
if flagFoundQ and flagFoundQQ:
|
|
|
|
@ -965,7 +965,7 @@ class fileHeader(HParams, _terms):
|
|
|
|
# Символ комментария
|
|
|
|
# Символ комментария
|
|
|
|
comment = False
|
|
|
|
comment = False
|
|
|
|
# Выражение для поиска строки интерпретатора
|
|
|
|
# Выражение для поиска строки интерпретатора
|
|
|
|
reExecStr = re.compile("^(#!/.+[^#]\s)", re.M)
|
|
|
|
reExecStr = re.compile(r"^(#!/.+[^#]\s)", re.M)
|
|
|
|
# условные операторы
|
|
|
|
# условные операторы
|
|
|
|
terms = ('>', '<', '==', '!=', '>=', '<=', '<>', '=>')
|
|
|
|
terms = ('>', '<', '==', '!=', '>=', '<=', '<>', '=>')
|
|
|
|
# параметры без значения
|
|
|
|
# параметры без значения
|
|
|
|
@ -996,7 +996,7 @@ class fileHeader(HParams, _terms):
|
|
|
|
# В случае текста XML
|
|
|
|
# В случае текста XML
|
|
|
|
if isinstance(comment, tuple) and len(comment) == 2:
|
|
|
|
if isinstance(comment, tuple) and len(comment) == 2:
|
|
|
|
reCalcHeader = \
|
|
|
|
reCalcHeader = \
|
|
|
|
re.compile("\s*%s\s+%s.+\s+(.+\n)+%s\s?" \
|
|
|
|
re.compile(r"\s*%s\s+%s.+\s+(.+\n)+%s\s?" \
|
|
|
|
% (comment[0], titleFirst, comment[1]),
|
|
|
|
% (comment[0], titleFirst, comment[1]),
|
|
|
|
re.M | re.I)
|
|
|
|
re.M | re.I)
|
|
|
|
reS = reCalcHeader.search(self.body)
|
|
|
|
reS = reCalcHeader.search(self.body)
|
|
|
|
@ -1004,7 +1004,7 @@ class fileHeader(HParams, _terms):
|
|
|
|
self.body = self.body[:reS.start()] + self.body[reS.end():]
|
|
|
|
self.body = self.body[:reS.start()] + self.body[reS.end():]
|
|
|
|
else:
|
|
|
|
else:
|
|
|
|
reCalcHeader = re.compile(
|
|
|
|
reCalcHeader = re.compile(
|
|
|
|
"\s*%s\-+\s+%s\s+%s.+\s+(%s.+\s+)+%s\-+\s?" \
|
|
|
|
r"\s*%s\-+\s+%s\s+%s.+\s+(%s.+\s+)+%s\-+\s?" \
|
|
|
|
% (comment, comment, titleFirst, comment, comment),
|
|
|
|
% (comment, comment, titleFirst, comment, comment),
|
|
|
|
re.M | re.I)
|
|
|
|
re.M | re.I)
|
|
|
|
reS = reCalcHeader.search(self.body)
|
|
|
|
reS = reCalcHeader.search(self.body)
|
|
|
|
@ -1020,7 +1020,7 @@ class fileHeader(HParams, _terms):
|
|
|
|
if textLines:
|
|
|
|
if textLines:
|
|
|
|
textLine = textLines[0]
|
|
|
|
textLine = textLines[0]
|
|
|
|
rePar = re.compile(
|
|
|
|
rePar = re.compile(
|
|
|
|
"\s*#\s*calculate\s+\\\\?|\s*#\s*calculate\\\\?$", re.I)
|
|
|
|
r"\s*#\s*calculate\s+\\\\?|\s*#\s*calculate\\\\?$", re.I)
|
|
|
|
reP = rePar.search(textLine)
|
|
|
|
reP = rePar.search(textLine)
|
|
|
|
if reP:
|
|
|
|
if reP:
|
|
|
|
reLns = re.compile(r"\A([^\\\n]*\\\n)+[^\n]*\n*", re.M)
|
|
|
|
reLns = re.compile(r"\A([^\\\n]*\\\n)+[^\n]*\n*", re.M)
|
|
|
|
@ -1030,7 +1030,7 @@ class fileHeader(HParams, _terms):
|
|
|
|
paramLine = self.body[reP.end():reLs.end()]
|
|
|
|
paramLine = self.body[reP.end():reLs.end()]
|
|
|
|
paramLine = paramLine.replace("\\", " ")
|
|
|
|
paramLine = paramLine.replace("\\", " ")
|
|
|
|
else:
|
|
|
|
else:
|
|
|
|
reLn = re.compile("\n")
|
|
|
|
reLn = re.compile(r"\n")
|
|
|
|
reL = reLn.search(self.body)
|
|
|
|
reL = reLn.search(self.body)
|
|
|
|
paramLine = textLine[reP.end():]
|
|
|
|
paramLine = textLine[reP.end():]
|
|
|
|
if reL:
|
|
|
|
if reL:
|
|
|
|
@ -1204,7 +1204,7 @@ class dirHeader(HParams, _terms):
|
|
|
|
if textLines:
|
|
|
|
if textLines:
|
|
|
|
textLine = textLines[0]
|
|
|
|
textLine = textLines[0]
|
|
|
|
rePar = re.compile(
|
|
|
|
rePar = re.compile(
|
|
|
|
"\s*#\s*calculate\s+\\\\?|\s*#\s*calculate\\\\?$", re.I)
|
|
|
|
r"\s*#\s*calculate\s+\\\\?|\s*#\s*calculate\\\\?$", re.I)
|
|
|
|
reP = rePar.search(textLine)
|
|
|
|
reP = rePar.search(textLine)
|
|
|
|
if reP:
|
|
|
|
if reP:
|
|
|
|
reLns = re.compile(r"\A([^\\\n]*\\\n)+[^\n]*\n*", re.M)
|
|
|
|
reLns = re.compile(r"\A([^\\\n]*\\\n)+[^\n]*\n*", re.M)
|
|
|
|
@ -1214,7 +1214,7 @@ class dirHeader(HParams, _terms):
|
|
|
|
paramLine = text[reP.end():reLs.end()]
|
|
|
|
paramLine = text[reP.end():reLs.end()]
|
|
|
|
paramLine = paramLine.replace("\\", " ")
|
|
|
|
paramLine = paramLine.replace("\\", " ")
|
|
|
|
else:
|
|
|
|
else:
|
|
|
|
reLn = re.compile("\n")
|
|
|
|
reLn = re.compile(r"\n")
|
|
|
|
reL = reLn.search(text)
|
|
|
|
reL = reLn.search(text)
|
|
|
|
paramLine = textLine[reP.end():]
|
|
|
|
paramLine = textLine[reP.end():]
|
|
|
|
if reL:
|
|
|
|
if reL:
|
|
|
|
@ -1794,12 +1794,12 @@ class utfBin(object):
|
|
|
|
|
|
|
|
|
|
|
|
def decode(self, text):
|
|
|
|
def decode(self, text):
|
|
|
|
"""Декодирует UTF-8 в смешанный формат"""
|
|
|
|
"""Декодирует UTF-8 в смешанный формат"""
|
|
|
|
varStart = "__hex__\?"
|
|
|
|
varStart = r"__hex__\?"
|
|
|
|
varEnd = "\?__hex__"
|
|
|
|
varEnd = r"\?__hex__"
|
|
|
|
# -1 Это экранирование '?' которое тоже считается
|
|
|
|
# -1 Это экранирование '?' которое тоже считается
|
|
|
|
deltVarStart = len(varStart) - 1
|
|
|
|
deltVarStart = len(varStart) - 1
|
|
|
|
deltVarEnd = len(varEnd) - 1
|
|
|
|
deltVarEnd = len(varEnd) - 1
|
|
|
|
reVar = re.compile("%s[a-f0-9]+%s" % (varStart, varEnd), re.M)
|
|
|
|
reVar = re.compile(r"%s[a-f0-9]+%s" % (varStart, varEnd), re.M)
|
|
|
|
resS = reVar.search(text)
|
|
|
|
resS = reVar.search(text)
|
|
|
|
textTemplateTmp = text
|
|
|
|
textTemplateTmp = text
|
|
|
|
while resS:
|
|
|
|
while resS:
|
|
|
|
@ -2010,10 +2010,10 @@ class templateFunction(_error, _warning, _shareTemplate, _shareTermsFunction,
|
|
|
|
templateFunction = {}
|
|
|
|
templateFunction = {}
|
|
|
|
|
|
|
|
|
|
|
|
# Регулярное выражение для сложения
|
|
|
|
# Регулярное выражение для сложения
|
|
|
|
sNum = re.compile("\-[^\-\+]+|[^\-\+]+")
|
|
|
|
sNum = re.compile(r"\-[^\-\+]+|[^\-\+]+")
|
|
|
|
|
|
|
|
|
|
|
|
# Регулярное выражение для умножениея и деления
|
|
|
|
# Регулярное выражение для умножениея и деления
|
|
|
|
sMD = re.compile("[^\-\+\*/]+")
|
|
|
|
sMD = re.compile(r"[^\-\+\*/]+")
|
|
|
|
|
|
|
|
|
|
|
|
# директория установленных программ
|
|
|
|
# директория установленных программ
|
|
|
|
_basePkgDir = "/var/db/pkg"
|
|
|
|
_basePkgDir = "/var/db/pkg"
|
|
|
|
@ -2026,11 +2026,11 @@ class templateFunction(_error, _warning, _shareTemplate, _shareTermsFunction,
|
|
|
|
stackGlobalVars = []
|
|
|
|
stackGlobalVars = []
|
|
|
|
|
|
|
|
|
|
|
|
# регулярное выражение для поиска версии
|
|
|
|
# регулярное выражение для поиска версии
|
|
|
|
reFindVer = re.compile("(?<=-)(?:\d+)(?:(?:\.\d+)*)"
|
|
|
|
reFindVer = re.compile(r"(?<=-)(?:\d+)(?:(?:\.\d+)*)"
|
|
|
|
"(?:[a-z]?)(?:(?:_(?:pre|p|beta|alpha|rc)\d*)*)"
|
|
|
|
r"(?:[a-z]?)(?:(?:_(?:pre|p|beta|alpha|rc)\d*)*)"
|
|
|
|
"(?:-r\d+)?$")
|
|
|
|
r"(?:-r\d+)?$")
|
|
|
|
|
|
|
|
|
|
|
|
reEmptyLoad = re.compile("^\s*$|^\s*;|^\s*#")
|
|
|
|
reEmptyLoad = re.compile(r"^\s*$|^\s*;|^\s*#")
|
|
|
|
|
|
|
|
|
|
|
|
# Имя обрабатываемого шаблона
|
|
|
|
# Имя обрабатываемого шаблона
|
|
|
|
nameTemplate = ""
|
|
|
|
nameTemplate = ""
|
|
|
|
@ -2040,8 +2040,8 @@ class templateFunction(_error, _warning, _shareTemplate, _shareTermsFunction,
|
|
|
|
|
|
|
|
|
|
|
|
# regular for discard sort number and version
|
|
|
|
# regular for discard sort number and version
|
|
|
|
reData = re.compile(r"^(?:\d+-)?(.+?)(?:-(?:|always|\d+|\d(?:\d|\.|pre|_"
|
|
|
|
reData = re.compile(r"^(?:\d+-)?(.+?)(?:-(?:|always|\d+|\d(?:\d|\.|pre|_"
|
|
|
|
"|-always|alpha|beta|pre|rc|[a-z][^a-z])*[a-z]?)(?:"
|
|
|
|
r"|-always|alpha|beta|pre|rc|[a-z][^a-z])*[a-z]?)(?:"
|
|
|
|
"-r\d+)?)?$", re.S)
|
|
|
|
r"-r\d+)?)?$", re.S)
|
|
|
|
|
|
|
|
|
|
|
|
currentAction = HParams.ActionType.Merge
|
|
|
|
currentAction = HParams.ActionType.Merge
|
|
|
|
|
|
|
|
|
|
|
|
@ -2093,11 +2093,11 @@ class templateFunction(_error, _warning, _shareTemplate, _shareTermsFunction,
|
|
|
|
self.namesTemplateFunction.append(nameFunction)
|
|
|
|
self.namesTemplateFunction.append(nameFunction)
|
|
|
|
# Объект хранения переменных
|
|
|
|
# Объект хранения переменных
|
|
|
|
self.objVar = objVar
|
|
|
|
self.objVar = objVar
|
|
|
|
self._reFunc = re.compile("%s%s%s"
|
|
|
|
self._reFunc = re.compile(r"%s%s%s"
|
|
|
|
% (self.varStart, self._reFunctionText,
|
|
|
|
% (self.varStart, self._reFunctionText,
|
|
|
|
self.varEnd), re.M)
|
|
|
|
self.varEnd), re.M)
|
|
|
|
self._rePrePattern = "%s.{%%d,}?%s" % (self.varStart, self.varEnd)
|
|
|
|
self._rePrePattern = r"%s.{%%d,}?%s" % (self.varStart, self.varEnd)
|
|
|
|
self._rePreFuncPattern = "%s.{%%d,}?\)%s" % (self.varStart, self.varEnd)
|
|
|
|
self._rePreFuncPattern = r"%s.{%%d,}?\)%s" % (self.varStart, self.varEnd)
|
|
|
|
# Аттрибуты для функции шаблона ini()
|
|
|
|
# Аттрибуты для функции шаблона ini()
|
|
|
|
# Первоначальный словарь переменных для ini()
|
|
|
|
# Первоначальный словарь переменных для ini()
|
|
|
|
self.prevDictIni = {}
|
|
|
|
self.prevDictIni = {}
|
|
|
|
@ -2303,7 +2303,7 @@ class templateFunction(_error, _warning, _shareTemplate, _shareTermsFunction,
|
|
|
|
pattern = r" "
|
|
|
|
pattern = r" "
|
|
|
|
|
|
|
|
|
|
|
|
pattern = pattern.replace(r"\1", "{0}")
|
|
|
|
pattern = pattern.replace(r"\1", "{0}")
|
|
|
|
pattern = re.sub(r"(^|[^\\])\\n", "\\1\n", pattern)
|
|
|
|
pattern = re.sub(r"(^|[^\\])\\n", r"\\1\n", pattern)
|
|
|
|
pattern = pattern.replace(r"\n", "\n")
|
|
|
|
pattern = pattern.replace(r"\n", "\n")
|
|
|
|
pattern = pattern.replace(r"\t", "\t")
|
|
|
|
pattern = pattern.replace(r"\t", "\t")
|
|
|
|
|
|
|
|
|
|
|
|
@ -2612,7 +2612,7 @@ class templateFunction(_error, _warning, _shareTemplate, _shareTermsFunction,
|
|
|
|
Функция grep (...), выдает значение из файла по регулярному выражению
|
|
|
|
Функция grep (...), выдает значение из файла по регулярному выражению
|
|
|
|
"""
|
|
|
|
"""
|
|
|
|
fname, op, regpattern = funArgv.replace(" ", "").partition(",")
|
|
|
|
fname, op, regpattern = funArgv.replace(" ", "").partition(",")
|
|
|
|
regpattern = regpattern.replace("(?\<", "(?<")
|
|
|
|
regpattern = regpattern.replace(r"(?\<", "(?<")
|
|
|
|
regpattern = self._replace_hex(regpattern)
|
|
|
|
regpattern = self._replace_hex(regpattern)
|
|
|
|
if not fname or not regpattern:
|
|
|
|
if not fname or not regpattern:
|
|
|
|
raise self.raiseErrTemplate()
|
|
|
|
raise self.raiseErrTemplate()
|
|
|
|
@ -3047,13 +3047,13 @@ class templateFunction(_error, _warning, _shareTemplate, _shareTermsFunction,
|
|
|
|
|
|
|
|
|
|
|
|
wpath = pathJoin(self._baseDir, wpath)
|
|
|
|
wpath = pathJoin(self._baseDir, wpath)
|
|
|
|
if os.path.isdir(wpath):
|
|
|
|
if os.path.isdir(wpath):
|
|
|
|
re_resol = re.compile("^(\d+)x(\d+)(-\d+(@\d+)?)?$")
|
|
|
|
re_resol = re.compile(r"^(\d+)x(\d+)(-\d+(@\d+)?)?$")
|
|
|
|
resol = re_resol.match(resol)
|
|
|
|
resol = re_resol.match(resol)
|
|
|
|
if not resol:
|
|
|
|
if not resol:
|
|
|
|
raise self.raiseErrTemplate(
|
|
|
|
raise self.raiseErrTemplate(
|
|
|
|
_("the first parameter must be the resolution"))
|
|
|
|
_("the first parameter must be the resolution"))
|
|
|
|
|
|
|
|
|
|
|
|
re_resol = re.compile(".*?(\d+)x(\d+).*")
|
|
|
|
re_resol = re.compile(r".*?(\d+)x(\d+).*")
|
|
|
|
res = map(lambda x: (int(x.group(1)), int(x.group(2)), x.group()),
|
|
|
|
res = map(lambda x: (int(x.group(1)), int(x.group(2)), x.group()),
|
|
|
|
filter(None,
|
|
|
|
filter(None,
|
|
|
|
map(re_resol.search,
|
|
|
|
map(re_resol.search,
|
|
|
|
@ -3888,11 +3888,11 @@ class Template(_file, _terms, _warning, xmlShare, _shareTemplate):
|
|
|
|
self._titleBody = ""
|
|
|
|
self._titleBody = ""
|
|
|
|
# Условия
|
|
|
|
# Условия
|
|
|
|
self._reTermBloc = re.compile(
|
|
|
|
self._reTermBloc = re.compile(
|
|
|
|
"#\?(?P<rTerm>(?:[a-z0-9_]+\.)?[a-zA-Z0-9\-_]+)"
|
|
|
|
r"#\?(?P<rTerm>(?:[a-z0-9_]+\.)?[a-zA-Z0-9\-_]+)"
|
|
|
|
"(?P<func>\(((?:#-|-#|%s)+|)\))?"
|
|
|
|
r"(?P<func>\(((?:#-|-#|%s)+|)\))?"
|
|
|
|
"(?P<lTerm>[><=!&\|]+"
|
|
|
|
r"(?P<lTerm>[><=!&\|]+"
|
|
|
|
"(?:#-|-#|[><=!\|&\(\)%s])*)#"
|
|
|
|
r"(?:#-|-#|[><=!\|&\(\)%s])*)#"
|
|
|
|
"\n?(?P<body>.+?\n*?)\n?#(?P=rTerm)#(?P<end>[ ,\t]*\n?)"
|
|
|
|
r"\n?(?P<body>.+?\n*?)\n?#(?P=rTerm)#(?P<end>[ ,\t]*\n?)"
|
|
|
|
% (self._reFunctionArgvText, self._reFunctionArgvInSquareBrackets),
|
|
|
|
% (self._reFunctionArgvText, self._reFunctionArgvInSquareBrackets),
|
|
|
|
re.M | re.S)
|
|
|
|
re.M | re.S)
|
|
|
|
# Объект с переменными
|
|
|
|
# Объект с переменными
|
|
|
|
@ -4113,8 +4113,8 @@ gettext -d cl_template "$*"
|
|
|
|
return createDirs
|
|
|
|
return createDirs
|
|
|
|
|
|
|
|
|
|
|
|
reBlock = re.compile(
|
|
|
|
reBlock = re.compile(
|
|
|
|
"#\?(?P<rTerm>(?:[a-z0-9_]+\.)?[a-zA-Z0-9\-_]+).*?#(?P=rTerm)#"
|
|
|
|
r"#\?(?P<rTerm>(?:[a-z0-9_]+\.)?[a-zA-Z0-9\-_]+).*?#(?P=rTerm)#"
|
|
|
|
"(?:[ ,\t]*\n?)",
|
|
|
|
r"(?:[ ,\t]*\n?)",
|
|
|
|
re.S | re.M)
|
|
|
|
re.S | re.M)
|
|
|
|
|
|
|
|
|
|
|
|
def applyTermsTemplate(self, textTemplate, nameTemplate):
|
|
|
|
def applyTermsTemplate(self, textTemplate, nameTemplate):
|
|
|
|
@ -4297,7 +4297,7 @@ gettext -d cl_template "$*"
|
|
|
|
if textLines:
|
|
|
|
if textLines:
|
|
|
|
textLine = textLines[0]
|
|
|
|
textLine = textLines[0]
|
|
|
|
rePar = re.compile(
|
|
|
|
rePar = re.compile(
|
|
|
|
"\s*#\s*calculate\s+\\\\?|\s*#\s*calculate\\\\?$", re.I)
|
|
|
|
r"\s*#\s*calculate\s+\\\\?|\s*#\s*calculate\\\\?$", re.I)
|
|
|
|
reP = rePar.search(textLine)
|
|
|
|
reP = rePar.search(textLine)
|
|
|
|
if reP:
|
|
|
|
if reP:
|
|
|
|
reLns = re.compile(r"\A([^\\\n]*\\\n)+[^\n]*\n*", re.M)
|
|
|
|
reLns = re.compile(r"\A([^\\\n]*\\\n)+[^\n]*\n*", re.M)
|
|
|
|
@ -4911,7 +4911,7 @@ gettext -d cl_template "$*"
|
|
|
|
ver_nor = prev_ver.partition("-")[0]
|
|
|
|
ver_nor = prev_ver.partition("-")[0]
|
|
|
|
# rc даже после уже существующего гарантирует, что версия будет
|
|
|
|
# rc даже после уже существующего гарантирует, что версия будет
|
|
|
|
# считаться ниже
|
|
|
|
# считаться ниже
|
|
|
|
#reRc = re.compile("(.*rc)(\d+)(.*)")
|
|
|
|
#reRc = re.compile(r"(.*rc)(\d+)(.*)")
|
|
|
|
#rc_match = reRc.search(ver_nor)
|
|
|
|
#rc_match = reRc.search(ver_nor)
|
|
|
|
#if rc_match:
|
|
|
|
#if rc_match:
|
|
|
|
# rc_num = max(0, int(rc_match.group(2)) - 1)
|
|
|
|
# rc_num = max(0, int(rc_match.group(2)) - 1)
|
|
|
|
@ -6410,7 +6410,7 @@ gettext -d cl_template "$*"
|
|
|
|
title = title.encode("UTF-8")
|
|
|
|
title = title.encode("UTF-8")
|
|
|
|
|
|
|
|
|
|
|
|
# В случае пустого конфигурационного файла
|
|
|
|
# В случае пустого конфигурационного файла
|
|
|
|
reNoClean = re.compile("[^\s]", re.M)
|
|
|
|
reNoClean = re.compile(r"[^\s]", re.M)
|
|
|
|
if not self.textConfig or \
|
|
|
|
if not self.textConfig or \
|
|
|
|
not reNoClean.search(self.textConfig):
|
|
|
|
not reNoClean.search(self.textConfig):
|
|
|
|
self.textConfig = ""
|
|
|
|
self.textConfig = ""
|
|
|
|
|
idziubenko
3 years ago