156 строки
2,9 КиБ
Go
156 строки
2,9 КиБ
Go
package service
|
|
|
|
import (
|
|
"go/ast"
|
|
)
|
|
|
|
var (
|
|
classDeclarations []*Class
|
|
|
|
isInMethod = false
|
|
currentReceiverName = ""
|
|
)
|
|
|
|
type Class struct {
|
|
Name string
|
|
Struct *ast.StructType
|
|
methods []*ast.FuncDecl
|
|
}
|
|
|
|
func NewClass(className string) *Class {
|
|
return &Class{Name: className}
|
|
}
|
|
|
|
func (c *Class) String() (code string) {
|
|
code += c.classDefinitionToString()
|
|
code += c.methodImplementationsToString()
|
|
return
|
|
}
|
|
func (c *Class) classDefinitionToString() (code string) {
|
|
code = "class " + c.Name + " {"
|
|
code += "public:\n"
|
|
|
|
code += c.structToString()
|
|
code += "\n"
|
|
|
|
code += c.methodDeclarationsToString()
|
|
code += "\n"
|
|
|
|
code += "};\n"
|
|
return
|
|
}
|
|
func (c *Class) structToString() (code string) {
|
|
code += handleExpr(c.Struct)
|
|
code += "\n"
|
|
return
|
|
}
|
|
func (c *Class) methodDeclarationsToString() (code string) {
|
|
for _, m := range c.methods {
|
|
code += c.methodDeclarationToString(m)
|
|
}
|
|
code += "\n"
|
|
return
|
|
}
|
|
func (c *Class) methodDeclarationToString(m *ast.FuncDecl) (code string) {
|
|
code += " "
|
|
code += "void " + m.Name.String() + "();"
|
|
code += "\n"
|
|
return
|
|
}
|
|
|
|
func (c *Class) methodImplementationsToString() (code string) {
|
|
for _, m := range c.methods {
|
|
code += c.methodImplementationToString(m)
|
|
}
|
|
code += "\n"
|
|
return
|
|
}
|
|
|
|
func (c *Class) methodImplementationToString(m *ast.FuncDecl) (code string) {
|
|
code += "void "
|
|
code += c.Name + "::"
|
|
code += m.Name.String() + "("
|
|
|
|
code += ") {"
|
|
if len(m.Recv.List) > 0 {
|
|
n := m.Recv.List[0].Names
|
|
if len(n) > 0 {
|
|
isInMethod = true
|
|
currentReceiverName = n[0].Name
|
|
}
|
|
}
|
|
code += handleBlockStmt(m.Body)
|
|
isInMethod = false
|
|
code += "}"
|
|
|
|
code += "\n"
|
|
return
|
|
}
|
|
|
|
func (c *Class) AddMethod(m *ast.FuncDecl) {
|
|
c.methods = append(c.methods, m)
|
|
}
|
|
|
|
// Handlers
|
|
func handleClass(t *ast.TypeSpec) string {
|
|
st, ok := t.Type.(*ast.StructType)
|
|
if !ok {
|
|
return ""
|
|
}
|
|
|
|
addClassFromStructType(t.Name.String(), st)
|
|
|
|
return ""
|
|
}
|
|
func addClassFromStructType(name string, s *ast.StructType) {
|
|
c := createClass(name)
|
|
c.Struct = s
|
|
}
|
|
|
|
func handleMethodDeclaration(fd *ast.FuncDecl) string {
|
|
class := getOrCreateClassFromFuncDecl(fd)
|
|
class.AddMethod(fd)
|
|
return ""
|
|
}
|
|
|
|
func getOrCreateClassFromFuncDecl(fd *ast.FuncDecl) *Class {
|
|
n := getClassNameFromReceiver(fd.Recv)
|
|
return getOrCreateClass(n)
|
|
}
|
|
func getClassNameFromReceiver(recv *ast.FieldList) string {
|
|
for _, f := range recv.List {
|
|
return getClassNameFromStarReceiver(f.Type)
|
|
}
|
|
|
|
return ""
|
|
}
|
|
func getClassNameFromStarReceiver(expr ast.Expr) string {
|
|
switch e := expr.(type) {
|
|
case *ast.StarExpr:
|
|
return handleExpr(e.X)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func getOrCreateClass(className string) *Class {
|
|
for _, c := range classDeclarations {
|
|
if c.Name == className {
|
|
return c
|
|
}
|
|
}
|
|
|
|
return createClass(className)
|
|
}
|
|
|
|
func createClass(className string) *Class {
|
|
c := NewClass(className)
|
|
addClassDeclaration(c)
|
|
return c
|
|
}
|
|
|
|
func addClassDeclaration(c *Class) {
|
|
dlock.Lock()
|
|
defer dlock.Unlock()
|
|
|
|
classDeclarations = append(classDeclarations, c)
|
|
}
|