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 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 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 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 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, 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)
