Beispiel #1
0
func main() {
	var rt reflect.Type
	runtime.LockOSThread()
	outFilePath := filepath.Join(os.Args[1], "-gen-refsids.go")
	outSrc := "package cdom\n\n"
	//	collect all struct types and catch the HasSid struct type
	for _, rt = range cdr.Types {
		if rt.Kind() == reflect.Struct {
			if !spref(rt.Name(), "Lib", "Base", "Has", "Ref") {
				allStructs[rt.Name()] = rt
			}
			if rt.Name() == "HasSid" {
				hasSidType = rt
			}
		}
	}
	//	map all direct and indirect type dependencies on HasSid type
	mapTypeDeps(hasSidType)
	for rt, _ = range typeDeps {
		testResolvers(rt)
	}
	for rt, _ = range typeDeps {
		if rt != hasSidType {
			outSrc += writeResolverMethods(rt)
		}
	}
	for _, rt = range cdr.Types {
		if (rt.Kind() == reflect.Struct) && !spref(rt.Name(), "Sid", "Base") {
			outSrc += writeAccessorMethods(rt)
		}
	}
	uio.WriteTextFile(outFilePath, outSrc[:len(outSrc)-1]+"\n")
}
Beispiel #2
0
//	Attempts to xml.Unmarshal() all files in the "infiles" sub-directory of the specified directory path into the interface{} structure returned by the specified constructor.
//	For each such input file, then attempts to xml.MarshalIndent() said structure back into a new output XML file with the same name, in the "outfiles" sub-directory of the specified directory path.
func TestViaRemarshal(dirPath string, makeEmptyDoc func() interface{}) {
	var dirPathInFiles = filepath.Join(dirPath, "infiles")
	var dirPathOutFiles = filepath.Join(dirPath, "outfiles")
	var loadXmlDocFile = func(filename string, keepRecursing bool) bool {
		log.Printf("Loading %s", filename)
		doc, dataOrig := makeEmptyDoc(), uio.ReadBinaryFile(filename, true)
		err := xml.Unmarshal(dataOrig, doc)
		if err != nil {
			panic(err)
		}
		if OnDocLoaded != nil {
			OnDocLoaded(doc)
		}
		outFileName := filepath.Join(dirPathOutFiles, filepath.Base(filename))
		log.Printf("Writing %s", outFileName)
		dataFaks, err := xml.MarshalIndent(doc, "", "\t")
		if err != nil {
			panic(err)
		}
		uio.WriteTextFile(outFileName, strings.Trim(string(dataFaks), " \r\n\t"))
		log.Printf("Verifying...")
		if errs := verifyDocs(dataOrig, dataFaks); len(errs) > 0 {
			for _, err = range errs {
				log.Printf("%v", err)
			}
		}
		return keepRecursing
	}
	uio.WalkDirectory(dirPathInFiles, "", loadXmlDocFile, true)
}
Beispiel #3
0
func (me *Schema) MakeGoPkgSrcFile() (goOutFilePath string, err error) {
	var goOutDirPath = filepath.Join(filepath.Dir(me.loadLocalPath), goPkgPrefix+filepath.Base(me.loadLocalPath)+goPkgSuffix)
	goOutFilePath = filepath.Join(goOutDirPath, path.Base(me.loadUri)+".go")
	var bag = newPkgBag(me)
	for _, inc := range me.XMLIncludedSchemas {
		bag.Schema = inc
		inc.makePkg(bag)
	}
	bag.Schema = me
	me.hasElemAnnotation.makePkg(bag)
	bag.appendFmt(true, "")
	me.makePkg(bag)
	if err = uio.EnsureDirExists(filepath.Dir(goOutFilePath)); err == nil {
		err = uio.WriteTextFile(goOutFilePath, bag.assembleSource())
	}
	return
}
Beispiel #4
0
func main() {
	//	pkgreflect -novars=true -norecurs=true -nofuncs=false -gofile=-pkgreflect.go $dir
	runtime.LockOSThread()
	srcDirPath := os.Args[1]
	impPath := strings.Trim(strings.Replace(strings.Replace(strings.ToLower(srcDirPath), strings.ToLower(ugo.GopathSrc()), "", -1), "\\", "/", -1), "/")
	srcFilePath := filepath.Join(srcDirPath, "-pkgreflect.go")
	outDirPath := filepath.Join(srcDirPath, "pkgreflect")
	outFilePath := filepath.Join(outDirPath, "-gen-pkgreflect.go")
	if raw, err := exec.Command("pkgreflect", "-novars=true", "-norecurs=true", "-nofuncs=false", "-gofile=-pkgreflect.go", srcDirPath).CombinedOutput(); err != nil {
		print(err)
		panic(err)
	} else {
		if len(raw) > 0 {
			println(string(raw))
		}
		src := uio.ReadTextFile(srcFilePath, true, "")
		os.Remove(srcFilePath)
		src = strings.Replace(src, "package cdom", "package pkgreflect", -1)
		src = strings.Replace(src, "import \"reflect\"", "import \"reflect\"\nimport cdom \""+impPath+"\"", -1)
		src = strings.Replace(src, "((*", "((*cdom.", -1)
		src = strings.Replace(src, "ValueOf(", "ValueOf(cdom.", -1)
		uio.WriteTextFile(outFilePath, src)
	}
}
Beispiel #5
0
func main() {
	const (
		srcImpLib = `
func libs_%s(xn *xmlx.Node) {
	var (
		lib *cdom.Lib%sDefs
		def *cdom.%sDef
		id  string
	)
	for _, ln := range xcns(xn, "library_%s") {
		id = xas(ln, "id")
		if lib = cdom.All%sDefLibs[id]; lib == nil {
			lib = cdom.All%sDefLibs.AddNew(id)
		}
		for _, def = range objs_%sDef(ln, "%s") {
			if def != nil {
				lib.Add(def)
			}
		}
		lib.SetDirty()
	}
}
`
		srcImpObj = `
func obj_%s(xn *xmlx.Node, n string) (obj *cdom.%s) {
	if (xn != nil) && (len(n) > 0) {
		xn = xcn(xn, n)
	}
	if xn != nil {
		obj = init_%s(xn)
	}
	return
}
`
		srcImpInitCtor = `
func init_%s(xn *xmlx.Node) (obj *cdom.%s) {
	obj = cdom.New%s()
`
		srcImpInitNew = `
func init_%s(xn *xmlx.Node) (obj *cdom.%s) {
	obj = new(cdom.%s)
`
		srcImpN = `
func objs_%s(xn *xmlx.Node, n string) (objs []*cdom.%s) {
	xns := xcns(xn, n)
	objs = make([]*cdom.%s, len(xns))
	for i, xn := range xns {
		objs[i] = obj_%s(xn, "")
	}
	return
}
`
		srcLoad = `
func load_%s(xn *xmlx.Node, obj *cdom.%s) {

}
`
	)
	var (
		i                                    int
		ok, canDirty                         bool
		srcLibs, srcInits, srcObjs, srcLoads string
		ctorFunc                             reflect.Value
	)
	has := []string{"Asset", "Extras", "FxParamDefs", "ID", "Inputs", "Name", "ParamDefs", "ParamInsts", "Sid", "Sources", "Techniques"}
	flag.Parse()
	for n, t := range cdr.Types {
		if canDirty = false; !(strings.HasPrefix(n, "Lib") || strings.HasPrefix(n, "Mesh") || strings.HasPrefix(n, "Base") || strings.HasSuffix(n, "Base") || strings.HasPrefix(n, "Has") || strings.HasPrefix(n, "Ref")) {
			srcObjs += fmt.Sprintf(srcImpObj, n, n, n)
			if ctorFunc, ok = cdr.Functions["New"+n]; ok && ctorFunc.Type().NumIn() == 0 {
				srcInits += fmt.Sprintf(srcImpInitCtor, n, n, n)
			} else {
				srcInits += fmt.Sprintf(srcImpInitNew, n, n, n)
			}
			if t.Kind() == reflect.Struct {
				for i = 0; i < t.NumField(); i++ {
					if strings.HasPrefix(t.Field(i).Name, "Base") {
						canDirty = true
					}
				}
				if canDirty {
					if strings.HasSuffix(n, "Def") || strings.HasSuffix(n, "Inst") {
						srcInits += "\tobj.Init()\n"
					}
					if strings.HasSuffix(n, "Inst") {
						srcInits += "\tsetInstDefRef(xn, &obj.BaseInst)\n"
					}
				}
				for _, h := range has {
					if _, ok = t.FieldByName("Has" + h); ok {
						srcInits += fmt.Sprintf("\thas_%s(xn, &obj.Has%s)\n", h, h)
					}
				}
			}
			srcInits += fmt.Sprintf("\n\tload_%s(xn, obj)", n)
			if canDirty {
				srcInits += "\n\tobj.SetDirty()"
			}
			srcInits += "\n\treturn\n}\n"
			srcObjs += fmt.Sprintf(srcImpN, n, n, n, n)
			srcLoads += fmt.Sprintf(srcLoad, n, n)
		}
	}
	for _, lm := range libs {
		//	animations Animation Animation animations Animation Animation Animation animation
		srcLibs += fmt.Sprintf(srcImpLib, lm.xnPlural, lm.tn, lm.tn, lm.xnPlural, lm.tn, lm.tn, lm.tn, lm.xnSingular)
	}
	srcLibs += "\nfunc libs_All (xn *xmlx.Node) {\n"
	for _, lm := range libs {
		srcLibs += fmt.Sprintf("\tlibs_%s(xn)\n", lm.xnPlural)
	}
	srcLibs += "}\n"
	uio.WriteTextFile(filepath.Join(*outDirPath, "-skel-libs.txt"), srcLibs)
	uio.WriteTextFile(filepath.Join(*outDirPath, "-skel-inits.txt"), srcInits)
	uio.WriteTextFile(filepath.Join(*outDirPath, "-skel-objs.txt"), srcObjs)
	uio.WriteTextFile(filepath.Join(*outDirPath, "-skel-loads.txt"), srcLoads)
}