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)