def exportLexems(self, level, lexems, style):
line = [
Lex.keyword('def'), Lex.space,
Lex.funcName(self.getName()), Lex.paramsBegin
]
paramLexems = []
isStatic = False
if self.owner.isClass() or (self.owner.type == 'overload'
and self.owner.owner.isClass()):
isStatic = self.isStatic()
if not isStatic:
paramLexems.append([Lex.keyword('self')])
for param in self.getParamsList():
pdef = []
param.exportLexems(0, pdef, style)
paramLexems.append(pdef)
if len(paramLexems) > 0:
for pl in paramLexems:
line += pl
line.append(Lex.paramDiv)
line[-1] = Lex.paramDivLast
line += [Lex.paramsEnd, Lex.colon]
if isStatic:
self.exportLine(level, lexems, style,
[Lex.keyword('@staticmethod')])
self.exportLine(level, lexems, style, line)
self.exportInternalComment(level + 1, lexems, style)
self.getBody().exportLexems(level + 1, lexems, style)
def exportMethod(method, lexems, style):
# access level
accessLevel = TaxonClass.getAccessLevelFor(method)
if accessLevel:
lexems += [Lex.keyword(accessLevel), Lex.space]
isConstructor = method.type == 'constructor'
# static
if method.isStatic():
lexems += [Lex.keyword('static'), Lex.space]
isConstructor = False
if isConstructor:
lexems.append(Lex.keyword('constructor'))
else:
lexems.append(Lex.funcName(method.getName()))
lexems.append(Lex.paramsBegin)
for param in method.getParamsList():
param.exportLexems(lexems, style)
lexems.append(Lex.paramDiv)
if lexems[-1] == Lex.paramDiv:
lexems[-1] = Lex.paramDivLast
lexems.append(Lex.paramsEnd)
if not isConstructor:
lexems.append(Lex.colon)
typeExpr = method.getResultTypeExpr()
if typeExpr:
typeExpr.exportLexems(lexems, style)
else:
lexems.append(Lex.typeName('void'))
method.getBody().exportLexems(lexems, style)
def exportLexems(self, lexems, rules):
if self.isConstructor():
lexems.append(Lex.keyword('super'))
elif self.isOverride():
lexems += [
Lex.keyword('super'), Lex.dot,
Lex.funcName(self.getTarget().getName())
]
def exportLexems(self, lexems, rules):
lexems.append(Lex.varName(self.getName()))
val = self.getValueTaxon()
if val:
lexems.append(Lex.binop('='))
val.exportLexems(lexems, rules)
else:
lexems.append(Lex.colon)
self.getTypeTaxon().exportLexems(lexems, rules)
def exportLexems(self, lexems, rules):
self.exportComment(lexems, rules)
if self.owner.isModule() and 'public' in self.attrs:
lexems += [Lex.keyword('export'), Lex.space]
lexems += [
Lex.keyword('const' if 'const' in self.attrs else 'let'), Lex.space
]
exportVar(self, lexems, rules)
lexems.append(Lex.instrDiv)
def exportLexems(self, level, lexems, style):
self.exportExternalComment(level, lexems, style)
line = [
Lex.keyword('self'), Lex.dot,
Lex.varName(self.getName()),
Lex.binop('=')
]
self.getValueTaxon().exportLexems(0, line, style)
self.exportLine(level, lexems, style, line)
def exportLexems(self, lexems, rules):
self.exportComment(lexems, rules)
if 'public' in self.attrs:
lexems += [Lex.keyword('export'), Lex.space]
lexems += [
Lex.keyword('type'), Lex.space,
Lex.typeName(self.getName()),
Lex.binop('=')
]
self.getTypeExpr().exportLexems(lexems, rules)
lexems.append(Lex.instrDiv)
def exportLexems(self, lexems, rules):
self.exportComment(lexems, rules)
# access level
accessLevel = TaxonClass.getAccessLevelFor(self)
if accessLevel:
lexems += [Lex.keyword(accessLevel), Lex.space]
# static
if 'static' in self.attrs:
lexems += [Lex.keyword('static'), Lex.space]
exportVar(self, lexems, rules)
lexems.append(Lex.instrDiv)
def exportLexems(self, lexems, rules):
struct = self.getStructure()
for cmd, cond, body in struct:
if cmd == 'elif':
lexems += [Lex.keyword('else'), Lex.space, Lex.keyword('if')]
else:
lexems.append(Lex.keyword(cmd))
if cond:
lexems.append(Lex.bracketBegin)
cond.exportLexems(lexems, rules)
lexems.append(Lex.bracketEnd)
body.exportLexems(lexems, rules)
def exportLexems(self, level, lexems, style):
if self.isConstructor():
lexems += [
Lex.keyword('super'), Lex.bracketBegin, Lex.bracketEnd,
Lex.dot,
Lex.funcName('__init__')
]
elif self.isOverride():
lexems += [
Lex.keyword('super'), Lex.bracketBegin, Lex.bracketEnd,
Lex.dot,
Lex.funcName(self.getTarget().getName())
]
def exportZeroConstructor(self, level, lexems, style, fields):
"""
Для исходного класса конструктор не определен. Значит его полностью формируем под определение полей
"""
if len(fields) == 0:
return
line = [
Lex.keyword('def'), Lex.space,
Lex.keyword('__init__'), Lex.paramsBegin,
Lex.keyword('self'), Lex.paramsEnd, Lex.colon
]
self.exportLine(level, lexems, style, line)
for field in fields:
field.exportLexems(level + 1, lexems, style)
def exportVar(var, lexems, rules):
if var.type == 'field':
lexems.append(Lex.fieldName(var.getName()))
else:
lexems.append(Lex.varName(var.getName()))
# Возможна ситуация, когда тип не указывается при объявлении. Если он следует из выражения
txType = var.getTypeTaxon()
if 'hiddenType' not in var.attrs:
lexems.append(Lex.colon)
txType.exportLexems(lexems, rules)
txValue = var.getValueTaxon()
if txValue:
lexems.append(Lex.binop('='))
txValue.exportLexems(lexems, rules)
def exportLexems(self, level, lexems, style):
expr = self.getResult()
line = [Lex.keyword('return')]
if expr:
line.append(Lex.space)
expr.exportLexems(level, line, style)
self.exportLine(level, lexems, style, line)
def exportLexems(self, lexems, style):
if self.owner.isModule() and 'public' in self.attrs:
lexems += [Lex.keyword('export'), Lex.space]
lexems += [
Lex.keyword('class'), Lex.space,
Lex.className(self.getName())
]
parent = self.getParent()
if parent:
lexems += [
Lex.space,
Lex.keyword('extends'), Lex.space,
Lex.className(parent.getName())
]
lexems.append(Lex.bodyBegin)
for taxon in self.items:
taxon.exportLexems(lexems, style)
lexems.append(Lex.bodyEnd)
def exportLexems(self, level, lexems, style):
line = []
self.getLeft().exportLexemsPrior(line, style)
line.append(Lex.binop(self.getOpcode()))
self.getRight().exportLexemsPrior(line, style)
if 'instruction' in self.attrs:
self.exportLine(level, lexems, style, line)
else:
lexems += line
def exportLexems(self, level, lexems, rules): struct = self.getStructure() for cmd, cond, body in struct: line = [Lex.keyword(cmd)] if cond: line.append(Lex.space) cond.exportLexems(level, line, rules) line.append(Lex.colon) self.exportLine(level, lexems, rules, line) body.exportLexems(level + 1, lexems, rules)
def testParams(self):
style['printWidth'] = 1000
# function applyStyle(lexems: Lexem[], pos: number, isVertical: boolean, style: Styles): {value: string, pos: number} {}
lexems = [
('function', 'keyword'),
Lex.space,
('applyStyle', 'funcName'),
Lex.paramsBegin,
('lexems', 'varName'),
Lex.colon,
('Lexem', 'typeName'),
Lex.arrayBegin,
Lex.arrayEnd,
Lex.paramDiv,
('pos', 'varName'),
Lex.colon,
Lex.typeName('number'),
Lex.paramDiv,
Lex.varName('isVertical'),
Lex.colon,
Lex.typeName('boolean'),
Lex.paramDiv,
Lex.varName('style'),
Lex.colon,
Lex.typeName('Styles'),
Lex.paramsEnd,
Lex.colon,
Lex.objBegin,
Lex.fieldName('value'),
Lex.colon,
Lex.typeName('string'),
Lex.itemDiv,
Lex.fieldName('pos'),
Lex.colon,
Lex.typeName('number'),
Lex.objEnd,
Lex.bodyBegin,
Lex.bodyEnd,
]
outRows = []
formatLexems(outRows, lexems, 0, 0, style)
# for row in outRows:
# print('<<<%s>>>' % row.replace(' ', '_'))
self.assertEqual(outRows, [
"function applyStyle(lexems: Lexem[], pos: number, isVertical: boolean, style: Styles): {value: string, pos: number} {",
"}"
])
def exportBinOp(self, binOp, style):
obj = binOp.getLeft()
arg = binOp.getRight()
if 'right' in self.attrs:
obj, arg = arg, obj
lexems = []
obj.exportLexems(lexems, style)
lexems += [Lex.dot, Lex.funcName(self.getName()), Lex.bracketBegin]
arg.exportLexems(lexems, style)
lexems.append(Lex.bracketEnd)
return lexems
def exportLexems(self, lexems, rules):
expr = self.getResult()
if 'shortForm' in self.owner.attrs:
# В cлучае короткой формы нужно экспортировать только выражение
expr.exportLexems(lexems, rules)
return
lexems.append(Lex.keyword('return'))
if expr:
lexems.append(Lex.space)
expr.exportLexems(lexems, rules)
lexems.append(Lex.instrDiv)
def exportLexems(self, lexems, style):
# TODO: сформировать JSDoc
# export, if public module member
if self.owner.isModule() and 'public' in self.attrs:
lexems += [Lex.keyword('export'), Lex.space]
# const funcName = (
lexems += [
Lex.keyword('const'), Lex.space,
Lex.funcName(self.getName()),
Lex.binop('='), Lex.paramsBegin
]
for param in self.getParamsList():
param.exportLexems(lexems, style)
lexems.append(Lex.paramDiv)
if lexems[-1] == Lex.paramDiv:
lexems[-1] = Lex.paramDivLast
# ): {void | resultType} =>
lexems += [Lex.paramsEnd, Lex.colon]
typeExpr = self.getResultTypeExpr()
if typeExpr:
typeExpr.exportLexems(lexems, style)
else:
lexems.append(Lex.typeName('void'))
lexems.append(Lex.binop('=>'))
self.getBody().exportLexems(lexems, style)
lexems.append(Lex.instrDiv)
def exportLexems(self, level, lexems, style):
target = self.getCaller().getTarget()
constr = target.findConstructor()
newLex = [Lex.className(target.getName())]
if constr and constr.type == 'overload':
if not self.overloadKey:
pass
else:
realConstr = constr.getImplementationByKey(self.overloadKey)
if realConstr.isStatic():
newLex += [
Lex.dot,
Lex.funcName(TaxonAltName.getAltName(realConstr))
]
lexems += newLex
lexems.append(Lex.bracketBegin)
args = self.getArguments()
if len(args):
for arg in args:
arg.exportLexems(level, lexems, style)
lexems.append(Lex.paramDiv)
lexems[-1] = Lex.paramDivLast
lexems.append(Lex.bracketEnd)
def exportLexems(self, lexems, style):
target = self.getCaller().getTarget()
lexTargetName = Lex.className(target.getName())
bNew = True
if self.overloadKey:
# Static constructor
conOver = target.findConstructor()
realConstr = conOver.getImplementationByKey(self.overloadKey)
if realConstr.isStatic():
lexems += [
lexTargetName, Lex.dot,
Lex.funcName(realConstr.getName())
]
bNew = False
if bNew:
lexems += [Lex.keyword('new'), Lex.space, lexTargetName]
lexems.append(Lex.paramsBegin)
args = self.getArguments()
if len(args) > 0:
for arg in args:
arg.exportLexems(lexems, style)
lexems.append(Lex.paramDiv)
lexems[-1] = Lex.paramDivLast
lexems.append(Lex.paramsEnd)
def exportComment(self, lexems, style):
for row in TaxonComment.getComments(self):
lexems += [Lex.slashes(row), Lex.eol]
def exportLexems(self, lexems, style):
txType = self.getTypeTaxon()
lexems.append(Lex.typeName(txType.getName()))
def exportLine(self, level, lexems, rules, line): """ line = list of lexems for single line """ lexems.append(Lex.indent(level, rules)) lexems += line lexems.append(Lex.eol)
def exportLexems(self, level, lexems, style):
lexems.append(Lex.varName(self.getName()))
val = self.getValueTaxon()
if val:
lexems.append(Lex.binop('='))
val.exportLexems(0, lexems, style)
def exportLexems(self, level, lexems, style):
line = [Lex.keyword('class'), Lex.space, Lex.className(self.getName())]
parent = self.getParent()
if parent:
line += [
Lex.bracketBegin,
Lex.className(parent.getName()), Lex.bracketEnd
]
# Интерфейсы включать нет смысла, т.к в питоне утиная типизация, а наличие реализуемых методов проверяется в WPP
line.append(Lex.colon)
self.exportLine(level, lexems, style, line)
bodyLevel = level + 1
self.exportInternalComment(bodyLevel, lexems, style)
# Разделить члены класса по категориям
staticFields = []
fields = []
methods = []
if len(self.getMembers()) == 0:
self.exportLine(bodyLevel, lexems, style, [Lex.keyword('pass')])
for member in self.getMembers():
if member.type == 'field':
if member.isStatic():
staticFields.append(member)
else:
fields.append(member)
elif member.type in ('method', 'operator', 'overload'):
methods.append(member)
# TODO: потом появятся конструктор, операторы и тп
# Обозначить список нестатических полей через __slots__
if len(fields) > 0:
line = [Lex.keyword('__slots__'), Lex.binop('='), Lex.bracketBegin]
for f in fields:
line.append(Lex.stringRaw(f.getName(), style))
line.append(Lex.itemDiv)
line[-1] = Lex.itemDivLast
line.append(Lex.bracketEnd)
self.exportLine(bodyLevel, lexems, style, line)
# Список статическиз полей (точнее, в питоне это переменныхе класса. но работают так же как статические)
for field in staticFields:
line = [Lex.varName(field.getName()), Lex.binop('=')]
field.getValueTaxon().exportLexems(0, line, style)
self.exportLine(bodyLevel, lexems, style, line)
# Поля надо определить в конструкторе
con = self.findConstructor()
if con == None:
self.exportZeroConstructor(bodyLevel, lexems, style, fields)
else:
if self.isNeedAutoConstructor():
self.exportZeroConstructor(bodyLevel, lexems, style, fields)
con.exportLexems(bodyLevel, lexems, style)
# Методы
for method in methods:
method.exportLexems(bodyLevel, lexems, style)
def exportLexems(self, level, lexems, rules):
""" Экспорт объявления переменной, как отдельной строки """
self.exportExternalComment(level, lexems, rules)
line = [Lex.varName(self.getName()), Lex.binop('=')]
self.getValueTaxon().exportLexems(level, line, rules)
self.exportLine(level, lexems, rules, line)
def exportLexems(self, lexems, rules):
lexems += [Lex.slashes(self.text), Lex.eol]
def exportLexems(self, level, lexems, style):
if self.isEmpty():
self.exportLine(level, lexems, style, [Lex.keyword('pass')])
else:
for taxon in self.items:
taxon.exportLexems(level, lexems, style)
