|
@@ -1,1124 +0,0 @@
|
|
-#!/usr/bin/python
|
|
|
|
-
|
|
|
|
-import sys
|
|
|
|
-import os
|
|
|
|
-import copy
|
|
|
|
-import xml.etree.ElementTree as etree
|
|
|
|
-import uuid
|
|
|
|
-import getopt
|
|
|
|
-import zipfile
|
|
|
|
-import shutil
|
|
|
|
-
|
|
|
|
-EXT_MAPPING = { ".c": "c", ".cc": "cpp", ".cpp": "cpp", ".h": "h", ".s": "s"}
|
|
|
|
-
|
|
|
|
-def parseError(str):
|
|
|
|
- print("*** error: \""+str+"\"\n");
|
|
|
|
-
|
|
|
|
-def platformCompare(a, b):
|
|
|
|
- return cmp(a.count('*'), b.count('*'))
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def platformSubseteqTest(a, b):
|
|
|
|
- a4=a.split("-")
|
|
|
|
- b4=b.split("-")
|
|
|
|
- ret=len(a4)==len(b4)
|
|
|
|
- i=0
|
|
|
|
- while i<len(a4) and i<len(b4):
|
|
|
|
- ret=ret and (a4[i]==b4[i] or b4[i]=="*")
|
|
|
|
- i=i+1
|
|
|
|
-# sys.stderr.write("platformSubseteqTest("+a+", "+b+")="+str(ret))
|
|
|
|
- return ret
|
|
|
|
-
|
|
|
|
-def parseFile(node, ctx, list):
|
|
|
|
- path=node.attrib["path"]
|
|
|
|
- abs_path=os.path.join(ctx["base"], ctx["root"], path)
|
|
|
|
-# sys.stderr.write "path="+abs_path
|
|
|
|
- filterMatch=True
|
|
|
|
- if "platform" in node.attrib:
|
|
|
|
- filter=node.attrib["platform"]
|
|
|
|
- filterMatch=platformSubseteqTest(ctx["platform"], filter)
|
|
|
|
-
|
|
|
|
- if filterMatch:
|
|
|
|
- file_ext=os.path.splitext(path)[1]
|
|
|
|
- if file_ext in EXT_MAPPING:
|
|
|
|
- ext=EXT_MAPPING[file_ext]
|
|
|
|
- if os.path.exists(abs_path):
|
|
|
|
- install=None
|
|
|
|
- if "install" in node.attrib and node.attrib["install"]=="yes":
|
|
|
|
- install=os.path.dirname(os.path.relpath(abs_path, ctx["root"]))
|
|
|
|
-## sys.stderr.write install
|
|
|
|
- file_item={ "path": abs_path, "ext": ext, "install": install }
|
|
|
|
- if "x" in node.attrib:
|
|
|
|
- file_item["x"]=node.attrib["x"]
|
|
|
|
- list.append(file_item)
|
|
|
|
- else:
|
|
|
|
- parseError("file "+abs_path+" does not exist!")
|
|
|
|
- else:
|
|
|
|
- parseError("extension "+file_ext+" is unknown")
|
|
|
|
-
|
|
|
|
-def parseFiles(target, node, ctx):
|
|
|
|
- for child in list(node):
|
|
|
|
- if child.tag=="file":
|
|
|
|
- parseFile(child, ctx, target)
|
|
|
|
- else:
|
|
|
|
- parseError("unhandled element: "+child.tag)
|
|
|
|
-
|
|
|
|
-def setAttr(dict, node, tag):
|
|
|
|
- if tag in node.attrib:
|
|
|
|
- dict[tag]=node.attrib[tag]
|
|
|
|
-
|
|
|
|
-def fallbackCompare(a, b):
|
|
|
|
- return -cmp(a.count('-'), b.count('-'))
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def generateFallbackList(platform):
|
|
|
|
- ret=[]
|
|
|
|
- p4=platform.split("-")
|
|
|
|
- for i in range(1<<len(p4)):
|
|
|
|
- p=""
|
|
|
|
- for j in range(len(p4)):
|
|
|
|
- m=(i&(1<<j))==(1<<j)
|
|
|
|
-# print " "+str(i)+" "+str(j)+" "+str(m)+" "+p
|
|
|
|
- if m:
|
|
|
|
- if len(p)>0:
|
|
|
|
- p=p+"-"
|
|
|
|
- p=p+p4[j]
|
|
|
|
- if len(p)>0:
|
|
|
|
- ret.append(p)
|
|
|
|
- ret.sort(fallbackCompare)
|
|
|
|
- return ret
|
|
|
|
-
|
|
|
|
-def updateCtx(conf, ctx, node):
|
|
|
|
- if "root" in node.attrib:
|
|
|
|
- root=ctx["root"]
|
|
|
|
- ctx=copy.copy(ctx)
|
|
|
|
- rel_prj_path=os.path.split(ctx["root"])[1]
|
|
|
|
- prjconfigdir=os.path.join(ctx["config"], rel_prj_path, "config")
|
|
|
|
-# print "rel_prj_path="+rel_prj_path+" prjconfigdir="+prjconfigdir
|
|
|
|
- v=node.attrib["root"].format(platform=ctx["platform"], config=os.path.join(ctx["config"], "config"), prjconfig=prjconfigdir)
|
|
|
|
- f=node.attrib["root"].format(platform="{platform}", config=os.path.join(ctx["config"], "config"), prjconfig=prjconfigdir)
|
|
|
|
- if v!=f:
|
|
|
|
- conf["format"][os.path.join(root, v)]=os.path.join(root, f)
|
|
|
|
-
|
|
|
|
- ctx_root=os.path.join(root, v)
|
|
|
|
- if not os.path.exists(ctx_root):
|
|
|
|
- list=generateFallbackList(ctx["platform"])
|
|
|
|
- for p in list:
|
|
|
|
- v=node.attrib["root"].format(platform=p, config=os.path.join(ctx["config"], "config"), prjconfig=prjconfigdir)
|
|
|
|
- if os.path.exists(os.path.join(root, v)):
|
|
|
|
- map=os.path.join(root, v)
|
|
|
|
- conf["mapping"][map]=ctx_root
|
|
|
|
- ctx_root=map
|
|
|
|
- list=[]
|
|
|
|
- if not os.path.exists(ctx_root) and "platforms" in conf and ctx["platform"] in conf["platforms"] and "family" in conf["platforms"][ctx["platform"]]:
|
|
|
|
- family=conf["platforms"][ctx["platform"]]["family"]
|
|
|
|
- list=generateFallbackList(family)
|
|
|
|
-# print "list="+str(list)
|
|
|
|
- for p in list:
|
|
|
|
- v=node.attrib["root"].format(platform=p, config=os.path.join(ctx["config"], "config"), prjconfig= prjconfigdir)
|
|
|
|
- if os.path.exists(os.path.join(root, v)):
|
|
|
|
- map=os.path.join(root, v)
|
|
|
|
- conf["mapping"][map]=ctx_root
|
|
|
|
- ctx_root=map
|
|
|
|
- list=[]
|
|
|
|
- ctx["root"]=ctx_root
|
|
|
|
- return ctx
|
|
|
|
-
|
|
|
|
-def parseDefines(ctx, node, dict):
|
|
|
|
- value=None
|
|
|
|
- if "value" in node.attrib:
|
|
|
|
- value=node.attrib["value"]
|
|
|
|
- if "name" in node.attrib:
|
|
|
|
- name=node.attrib["name"]
|
|
|
|
- dict[name]=value
|
|
|
|
- else:
|
|
|
|
- parseError("define syntax invalid ("+nv+")");
|
|
|
|
-
|
|
|
|
-def parseSettings(conf, node, ctx, lib):
|
|
|
|
- if node.tag=="settings":
|
|
|
|
- tag="defines"
|
|
|
|
- elif node.tag=="export":
|
|
|
|
- tag="exports"
|
|
|
|
- else:
|
|
|
|
- parseError("unknown setting: "+node.tag);
|
|
|
|
- for child in list(node):
|
|
|
|
- if child.tag=="define":
|
|
|
|
- parseDefines(ctx, child, lib[tag])
|
|
|
|
- else:
|
|
|
|
- parseError("unhanded element: "+child.tag)
|
|
|
|
-
|
|
|
|
-def parseDeps(node):
|
|
|
|
- if "dep" in node.attrib:
|
|
|
|
- dep=node.attrib["dep"].split()
|
|
|
|
- return dep
|
|
|
|
- else:
|
|
|
|
- return []
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def parseLibrary(conf, node, ctx, seq_type):
|
|
|
|
- lib_name=node.attrib["name"]
|
|
|
|
- lib_uuid=uuid.uuid5(uuid.NAMESPACE_URL, "urn:lib:"+lib_name)
|
|
|
|
- lib={"name": lib_name, "uuid": lib_uuid, "source": { "files": []}, "header": { "files": [], "target": "", "includes": [] }, "defines": {}, "exports": {}, "deps": parseDeps(node), "mode": "c90", "align": "", "external": False }
|
|
|
|
- ctx=updateCtx(conf, ctx, node)
|
|
|
|
- setAttr(lib, node, "mode")
|
|
|
|
- setAttr(lib, node, "align")
|
|
|
|
- if not(lib_name in ctx["externals"]) or not("external" in ctx["externals"][lib_name]) or not(ctx["externals"][lib_name]["external"]):
|
|
|
|
- for child in list(node):
|
|
|
|
- if child.tag=="source":
|
|
|
|
- parseFiles(lib["source"]["files"], list(child), updateCtx(conf, ctx, child))
|
|
|
|
- elif child.tag=="header":
|
|
|
|
- setAttr(lib["header"], child, "target")
|
|
|
|
- child_ctx=updateCtx(conf, ctx, child)
|
|
|
|
- lib["header"]["includes"].append(child_ctx["root"])
|
|
|
|
- parseFiles(lib["header"]["files"], list(child), child_ctx)
|
|
|
|
- elif child.tag=="settings":
|
|
|
|
- parseSettings(conf, child, ctx, lib)
|
|
|
|
- elif child.tag=="export":
|
|
|
|
- parseSettings(conf, child, ctx, lib)
|
|
|
|
- else:
|
|
|
|
- parseError("unhanded element: "+child.tag)
|
|
|
|
- else:
|
|
|
|
- sys.stderr.write("using external "+lib_name)
|
|
|
|
- lib["external"]=True
|
|
|
|
- conf[seq_type].append(lib)
|
|
|
|
-
|
|
|
|
-def isExcluded(conf, ctx, lib):
|
|
|
|
-# sys.stderr.write conf["platforms"]
|
|
|
|
- if ctx["platform"] in conf["platforms"]:
|
|
|
|
- platform=conf["platforms"][ctx["platform"]]
|
|
|
|
- return lib in platform["exclude"]
|
|
|
|
- else:
|
|
|
|
- return False
|
|
|
|
-
|
|
|
|
-def parsePlatform(conf, node, ctx):
|
|
|
|
- if "name" in node.attrib:
|
|
|
|
- name=node.attrib["name"]
|
|
|
|
- platform={ "exclude": {}, "libs": [], "ldflags": "" }
|
|
|
|
- setAttr(platform, node, "family")
|
|
|
|
- setAttr(platform, node, "cc")
|
|
|
|
- setAttr(platform, node, "ar")
|
|
|
|
- setAttr(platform, node, "ld")
|
|
|
|
- setAttr(platform, node, "cflags")
|
|
|
|
- setAttr(platform, node, "cflags_c")
|
|
|
|
- setAttr(platform, node, "cflags_cpp")
|
|
|
|
- setAttr(platform, node, "cppflags")
|
|
|
|
- setAttr(platform, node, "ldflags")
|
|
|
|
- setAttr(platform, node, "host")
|
|
|
|
- if "exclude" in node.attrib:
|
|
|
|
- for prj in node.attrib["exclude"].split(" "):
|
|
|
|
- platform["exclude"][prj]=None
|
|
|
|
-# sys.stderr.write platform["exclude"]
|
|
|
|
- if "libs" in node.attrib:
|
|
|
|
- platform["libs"].extend(node.attrib["libs"].split(" "))
|
|
|
|
- conf["platforms"][name]=platform
|
|
|
|
- else:
|
|
|
|
- parseError("no name given for platform")
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def parseTargets(conf, node, ctx):
|
|
|
|
- for child in list(node):
|
|
|
|
- if child.tag=="include":
|
|
|
|
- path=os.path.abspath(os.path.join(ctx["root"], child.attrib["path"]))
|
|
|
|
- new_ctx=copy.copy(ctx)
|
|
|
|
- new_ctx["root"]=os.path.dirname(path)
|
|
|
|
- parseConfiguration(conf, path, new_ctx)
|
|
|
|
- elif child.tag=="library":
|
|
|
|
- parseLibrary(conf, child, ctx, "libraries")
|
|
|
|
- elif child.tag=="tool":
|
|
|
|
- parseLibrary(conf, child, ctx, "tools")
|
|
|
|
- elif child.tag=="platform":
|
|
|
|
- parsePlatform(conf, child, ctx)
|
|
|
|
- else:
|
|
|
|
- parseError("unhanded element: "+child.tag)
|
|
|
|
-
|
|
|
|
-def parseConfiguration(conf, filename, ctx):
|
|
|
|
- sys.stderr.write("parsing "+filename+"\n")
|
|
|
|
- tree=etree.parse(filename)
|
|
|
|
- if tree is not None:
|
|
|
|
- parseTargets(conf, tree.getroot(), ctx)
|
|
|
|
- else:
|
|
|
|
- parseError("failed to open file \""+filename+"\"")
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def depClosure2(conf, deps, ignoreExternal):
|
|
|
|
- ret=[]
|
|
|
|
- gray=set(deps)
|
|
|
|
- black=set()
|
|
|
|
- while len(gray)>0:
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if lib["name"] in gray:
|
|
|
|
- gray.remove(lib["name"])
|
|
|
|
- black.add(lib["name"])
|
|
|
|
- if not(ignoreExternal) or not(lib["external"]):
|
|
|
|
- ret.append((lib, []))
|
|
|
|
- lib_deps=lib["deps"]
|
|
|
|
- for lib_dep in lib_deps:
|
|
|
|
- if not lib_dep in black:
|
|
|
|
- gray.add(lib_dep)
|
|
|
|
- return ret
|
|
|
|
-
|
|
|
|
-def depCompare(a, b):
|
|
|
|
- if a[0] in b[1]:
|
|
|
|
- return 1
|
|
|
|
- elif b[0] in a[1]:
|
|
|
|
- return -1
|
|
|
|
- else:
|
|
|
|
- return 0
|
|
|
|
-
|
|
|
|
-def depClosureStr(req_deps, deps):
|
|
|
|
- ret="depClosure("+str(req_deps)+") ="
|
|
|
|
- for lib in deps:
|
|
|
|
- ret=ret+" "+lib[0]["name"]+"<"
|
|
|
|
- for x in lib[1]:
|
|
|
|
- ret=ret+" "+x[0]["name"]
|
|
|
|
- ret=ret+" >"
|
|
|
|
- return ret
|
|
|
|
-
|
|
|
|
-def depClosure(conf, req_deps, ignoreExternal):
|
|
|
|
- deps=depClosure2(conf, req_deps, ignoreExternal)
|
|
|
|
- for lib in deps:
|
|
|
|
- lib[1].extend(depClosure2(conf, lib[0]["deps"], ignoreExternal))
|
|
|
|
-# print depClosureStr(req_deps, deps)
|
|
|
|
-# deps.sort(depCompare)
|
|
|
|
-# print depClosureStr(req_deps, deps)
|
|
|
|
- ret=[]
|
|
|
|
- for lib in deps:
|
|
|
|
- ret.append(lib[0]["name"])
|
|
|
|
-# print "\n"
|
|
|
|
- return ret
|
|
|
|
-
|
|
|
|
-def gatherIncludeDirs(conf, ctx, deps):
|
|
|
|
- ret=[]
|
|
|
|
- aux={}
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if lib["name"] in deps:
|
|
|
|
- for file in lib["header"]["files"]:
|
|
|
|
- if file["install"] is not None:
|
|
|
|
- dir=os.path.dirname(file["path"])
|
|
|
|
- dir=os.path.abspath(dir.rstrip(file["install"]))
|
|
|
|
- dir=os.path.relpath(dir, ctx["base"])
|
|
|
|
- if dir not in aux:
|
|
|
|
- aux[dir]=None
|
|
|
|
- ret.append(dir)
|
|
|
|
-# sys.stderr.write ret
|
|
|
|
- return ret
|
|
|
|
-
|
|
|
|
-def gatherSources(conf, ctx, lib):
|
|
|
|
- sources=[]
|
|
|
|
- for file in lib["source"]["files"]:
|
|
|
|
- rel_source=os.path.relpath(file["path"], ctx["base"])
|
|
|
|
- sources.append((rel_source, file))
|
|
|
|
- return sources
|
|
|
|
-
|
|
|
|
-#def generateOBJS(conf, ctx, lib, out, obj_dir, cppflags):
|
|
|
|
-# objs=[]
|
|
|
|
-# for file in lib["source"]["files"]:
|
|
|
|
-# rel_source=os.path.relpath(file["path"], ctx["base"])
|
|
|
|
-# rel_obj=os.path.join(obj_dir, os.path.splitext(rel_source)[0]+".o")
|
|
|
|
-# out_dir=os.path.dirname(rel_obj)
|
|
|
|
-# out.write(rel_obj+": "+rel_source+"\n")
|
|
|
|
-# out.write("\t@mkdir -p "+out_dir+"\n")
|
|
|
|
-# specific=""
|
|
|
|
-# if file["ext"]=="c":
|
|
|
|
-# specific ="$(CFLAGS_C) "
|
|
|
|
-# elif file["ext"]=="cpp":
|
|
|
|
-# specific ="$(CFLAGS_CPP) "
|
|
|
|
-# out.write("\t$(CC) -c $(CFLAGS) "+ specific +"$(CPPFLAGS)"+cppflags+" "+ rel_source+" -o "+rel_obj+"\n")
|
|
|
|
-# objs.append(rel_obj)
|
|
|
|
-# return objs
|
|
|
|
-
|
|
|
|
-def generateDEPS(conf, ctx, lib, out, obj_dir, cppflags, filename):
|
|
|
|
- for file in lib["source"]["files"]:
|
|
|
|
- rel_source=os.path.relpath(file["path"], ctx["base"])
|
|
|
|
- specific=""
|
|
|
|
- if file["ext"]=="c":
|
|
|
|
- specific ="$(CFLAGS_C) "
|
|
|
|
- elif file["ext"]=="cpp":
|
|
|
|
- specific ="$(CFLAGS_CPP) "
|
|
|
|
- out.write("\tmakedepend -a -f"+filename+" $(CPPFLAGS)"+cppflags+" "+ rel_source+"\n")
|
|
|
|
-
|
|
|
|
-def generateCPPFLAGS(conf, ctx, lib, build_dir):
|
|
|
|
- cppflags=""
|
|
|
|
- for define in lib["defines"]:
|
|
|
|
- if lib["defines"][define] is None:
|
|
|
|
- cppflags=cppflags+" -D"+define
|
|
|
|
- else:
|
|
|
|
- cppflags=cppflags+" -D"+define+"="+lib["defines"][define]
|
|
|
|
- for dir in lib["header"]["includes"]:
|
|
|
|
- abs_dir=os.path.abspath(dir)
|
|
|
|
- rel_dir=os.path.relpath(abs_dir, os.path.join(ctx["base"], build_dir))
|
|
|
|
-# sys.stderr.write("abs_dir="+str(abs_dir)+" build_dir="+os.path.join(ctx["base"], build_dir)+" rel_dir="+str(rel_dir))
|
|
|
|
- cppflags=cppflags+" -I"+rel_dir
|
|
|
|
- dep_closure=depClosure(conf, lib["deps"], False)
|
|
|
|
- dep_dirs=gatherIncludeDirs(conf, ctx, dep_closure)
|
|
|
|
- for dir in dep_dirs:
|
|
|
|
- abs_dir=os.path.abspath(dir)
|
|
|
|
- rel_dir=os.path.relpath(abs_dir, os.path.join(ctx["base"], build_dir))
|
|
|
|
-# sys.stderr.write("abs_dir="+str(abs_dir)+" build_dir="+os.path.join(ctx["base"], build_dir)+" rel_dir="+str(rel_dir))
|
|
|
|
- cppflags=cppflags+" -I"+rel_dir
|
|
|
|
- for dep_lib in conf["libraries"]:
|
|
|
|
- if dep_lib["name"] in ctx["externals"]:
|
|
|
|
- ext_lib=ctx["externals"][dep_lib["name"]]
|
|
|
|
- if "external" in ext_lib and ext_lib["external"]:
|
|
|
|
- if "cppflags" in ext_lib:
|
|
|
|
- cppflags=cppflags+" "+ext_lib["cppflags"]
|
|
|
|
-
|
|
|
|
- return cppflags
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def generateVCXPROJ(conf, ctx, lib, type):
|
|
|
|
- filename=os.path.abspath("win32\\"+lib["name"]+"\\"+lib["name"]+".vcxproj")
|
|
|
|
- filepath=os.path.dirname(filename)
|
|
|
|
- prj_uuid=lib["uuid"]
|
|
|
|
- sys.stderr.write("generating "+filename+"\n")
|
|
|
|
- try:
|
|
|
|
- os.makedirs(os.path.dirname(filename))
|
|
|
|
- except OSError:
|
|
|
|
- pass
|
|
|
|
-
|
|
|
|
- out=open(filename, "w")
|
|
|
|
- out.write("<Project DefaultTargets=\"Build\" ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n");
|
|
|
|
- out.write("<ItemGroup Label=\"ProjectConfigurations\">\n");
|
|
|
|
- out.write(" <ProjectConfiguration Include=\"Debug|Win32\">\n");
|
|
|
|
- out.write(" <Configuration>Debug</Configuration>\n");
|
|
|
|
- out.write(" <Platform>Win32</Platform>\n");
|
|
|
|
- out.write(" </ProjectConfiguration>\n");
|
|
|
|
- out.write("<ProjectConfiguration Include=\"Release|Win32\">\n");
|
|
|
|
- out.write(" <Configuration>Release</Configuration>\n");
|
|
|
|
- out.write(" <Platform>Win32</Platform>\n");
|
|
|
|
- out.write("</ProjectConfiguration>\n");
|
|
|
|
- out.write("</ItemGroup>\n");
|
|
|
|
- out.write("<PropertyGroup Label=\"Globals\">\n");
|
|
|
|
- out.write(" <ProjectGuid>{"+str(prj_uuid)+"}</ProjectGuid>\n");
|
|
|
|
- out.write(" <Keyword>Win32Proj</Keyword>\n");
|
|
|
|
- out.write(" <RootNamespace>"+lib["name"]+"</RootNamespace>\n");
|
|
|
|
- out.write("</PropertyGroup>\n");
|
|
|
|
- out.write("<Import Project=\"$(VCTargetsPath)\Microsoft.Cpp.default.props\" />\n");
|
|
|
|
- out.write(" <PropertyGroup Condition=\"'$(Configuration)|$(Platform)'=='Debug|Win32'\" Label=\"Configuration\">\n");
|
|
|
|
- out.write(" <ConfigurationType>"+type+"</ConfigurationType>\n");
|
|
|
|
- out.write(" <UseDebugLibraries>true</UseDebugLibraries>\n");
|
|
|
|
- out.write(" <CharacterSet>Unicode</CharacterSet>\n");
|
|
|
|
- out.write(" </PropertyGroup>\n");
|
|
|
|
- out.write(" <PropertyGroup Condition=\"'$(Configuration)|$(Platform)'=='Release|Win32'\" Label=\"Configuration\">\n");
|
|
|
|
- out.write(" <ConfigurationType>"+type+"</ConfigurationType>\n");
|
|
|
|
- out.write(" <UseDebugLibraries>false</UseDebugLibraries>\n");
|
|
|
|
- out.write(" <WholeProgramOptimization>true</WholeProgramOptimization>\n");
|
|
|
|
- out.write(" <CharacterSet>Unicode</CharacterSet>\n");
|
|
|
|
- out.write(" </PropertyGroup>\n");
|
|
|
|
- out.write("<Import Project=\"$(VCTargetsPath)\Microsoft.Cpp.props\" />\n");
|
|
|
|
- out.write("<ImportGroup Label=\"ExtensionSettings\" />\n");
|
|
|
|
- out.write("<ImportGroup Label=\"PropertySheets\" />\n");
|
|
|
|
- out.write("<PropertyGroup Label=\"UserMacros\" />\n");
|
|
|
|
- out.write("<PropertyGroup />\n");
|
|
|
|
- out.write("<ItemDefinitionGroup>\n");
|
|
|
|
- out.write("<ClCompile>\n");
|
|
|
|
- dep_closure=depClosure(conf, lib["deps"], False)
|
|
|
|
- cpp_defs="WIN32;"
|
|
|
|
- for define in lib["defines"]:
|
|
|
|
- if lib["defines"][define] is None:
|
|
|
|
- cpp_defs=cpp_defs+define+";"
|
|
|
|
- else:
|
|
|
|
- cpp_defs=cpp_defs+define+"="+lib["defines"][define]+";"
|
|
|
|
- for dep in dep_closure:
|
|
|
|
- for dep_lib in conf["libraries"]:
|
|
|
|
- if dep_lib["name"]==dep and not isExcluded(conf, ctx, dep):
|
|
|
|
- for define in dep_lib["exports"]:
|
|
|
|
- if dep_lib["exports"][define] is None:
|
|
|
|
- cpp_defs=cpp_defs+define+";"
|
|
|
|
- else:
|
|
|
|
- cpp_defs=cpp_defs+define+"="+dep_lib["defines"][define]+";"
|
|
|
|
- cpp_defs=cpp_defs+"_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)"
|
|
|
|
- out.write("<PreprocessorDefinitions>"+cpp_defs+"</PreprocessorDefinitions>\n" )
|
|
|
|
- AdditionalIncludeDirectories=""
|
|
|
|
- for dir in lib["header"]["includes"]:
|
|
|
|
- AdditionalIncludeDirectories=AdditionalIncludeDirectories+os.path.relpath(os.path.abspath(dir), filepath)+";"
|
|
|
|
- dep_dirs=gatherIncludeDirs(conf, ctx, dep_closure)
|
|
|
|
- for dir in dep_dirs:
|
|
|
|
- abs_path=os.path.relpath(os.path.abspath(dir), filepath)
|
|
|
|
- AdditionalIncludeDirectories=AdditionalIncludeDirectories+abs_path+";"
|
|
|
|
- AdditionalIncludeDirectories=AdditionalIncludeDirectories+"%(AdditionalIncludeDirectories)"
|
|
|
|
- out.write("<AdditionalIncludeDirectories>"+AdditionalIncludeDirectories+"</AdditionalIncludeDirectories>\n")
|
|
|
|
- if "c99"==lib["mode"]:
|
|
|
|
- out.write("<CompileAs>CompileAsCpp</CompileAs>\n");
|
|
|
|
- if ""!=lib["align"]:
|
|
|
|
- out.write("<StructMemberAlignment>"+lib["align"]+"Byte</StructMemberAlignment>\n");
|
|
|
|
- out.write("</ClCompile>\n");
|
|
|
|
- if "Application"==type:
|
|
|
|
- out.write("<Link>\n");
|
|
|
|
- out.write("<AdditionalDependencies>")
|
|
|
|
- if ctx["platform"] in conf["platforms"]:
|
|
|
|
- ext_libs=conf["platforms"][ctx["platform"]]["libs"]
|
|
|
|
- else:
|
|
|
|
- ext_libs={}
|
|
|
|
-# sys.stderr.write ext_libs
|
|
|
|
- for ext_lib in ext_libs:
|
|
|
|
-# sys.stderr.write ext_lib
|
|
|
|
- out.write(ext_lib+";")
|
|
|
|
- out.write("%(AdditionalDependencies)</AdditionalDependencies> \n")
|
|
|
|
- out.write("</Link>\n");
|
|
|
|
- out.write("</ItemDefinitionGroup>\n");
|
|
|
|
-
|
|
|
|
-
|
|
|
|
- out.write("<ItemDefinitionGroup Condition=\"'$(Configuration)|$(Platform)'=='Debug|Win32'\">\n")
|
|
|
|
- out.write("<ClCompile>\n");
|
|
|
|
- out.write("<WarningLevel>Level3</WarningLevel>\n")
|
|
|
|
- out.write("<Optimization>Disabled</Optimization>\n")
|
|
|
|
- out.write("<DisableSpecificWarnings>4996</DisableSpecificWarnings>\n")
|
|
|
|
- out.write("</ClCompile>\n");
|
|
|
|
- if "Application"==type:
|
|
|
|
- out.write("<Link>\n");
|
|
|
|
- out.write("<GenerateDebugInformation>true</GenerateDebugInformation>\n")
|
|
|
|
- out.write("<SubSystem>Console</SubSystem>\n")
|
|
|
|
- out.write("</Link>\n");
|
|
|
|
- out.write("</ItemDefinitionGroup>\n");
|
|
|
|
-
|
|
|
|
- out.write("<ItemDefinitionGroup Condition=\"'$(Configuration)|$(Platform)'=='Release|Win32'\">\n")
|
|
|
|
- out.write("<ClCompile>\n")
|
|
|
|
- out.write("<Optimization>MaxSpeed</Optimization>\n")
|
|
|
|
- out.write("<DisableSpecificWarnings>4996</DisableSpecificWarnings>\n")
|
|
|
|
- out.write("<FunctionLevelLinking>true</FunctionLevelLinking> \n")
|
|
|
|
- out.write("<IntrinsicFunctions>true</IntrinsicFunctions> \n")
|
|
|
|
- out.write("</ClCompile>\n");
|
|
|
|
- if "Application"==type:
|
|
|
|
- out.write("<Link>\n");
|
|
|
|
- out.write("<GenerateDebugInformation>false</GenerateDebugInformation>\n")
|
|
|
|
- out.write("<SubSystem>Console</SubSystem>\n")
|
|
|
|
- out.write("<EnableCOMDATFolding>true</EnableCOMDATFolding>\n")
|
|
|
|
- out.write("<OptimizeReferences>true</OptimizeReferences>\n")
|
|
|
|
- out.write("</Link>\n");
|
|
|
|
- out.write("</ItemDefinitionGroup>\n");
|
|
|
|
-
|
|
|
|
- out.write("<ItemGroup>\n");
|
|
|
|
- for file in lib["header"]["files"]:
|
|
|
|
- if "h"==file["ext"]:
|
|
|
|
- out.write(" <ClInclude Include=\""+os.path.relpath(file["path"], filepath)+"\"/>\n");
|
|
|
|
- out.write("</ItemGroup>\n");
|
|
|
|
- out.write("<ItemGroup>\n");
|
|
|
|
- for file in lib["source"]["files"]:
|
|
|
|
- if "cpp"==file["ext"] or "c"==file["ext"] or "s"==file["ext"]:
|
|
|
|
- out.write(" <ClCompile Include=\""+os.path.relpath(file["path"], filepath)+"\">\n");
|
|
|
|
- out.write(" </ClCompile>\n");
|
|
|
|
- out.write("</ItemGroup>\n");
|
|
|
|
- out.write("<ItemGroup>\n");
|
|
|
|
- for dep in dep_closure:
|
|
|
|
- for dep_lib in conf["libraries"]:
|
|
|
|
- if dep_lib["name"]==dep and not isExcluded(conf, ctx, dep_lib["name"]):
|
|
|
|
- out.write("<ProjectReference Include=\"../"+dep_lib["name"]+"/"+dep_lib["name"]+".vcxproj\">\n")
|
|
|
|
- out.write("<Project>{"+str(dep_lib["uuid"])+"}</Project>\n")
|
|
|
|
- out.write("</ProjectReference>\n")
|
|
|
|
- out.write("</ItemGroup>\n")
|
|
|
|
- out.write("<Import Project=\"$(VCTargetsPath)\Microsoft.Cpp.targets\" />\n");
|
|
|
|
- out.write("<ImportGroup Label=\"ExtensionTargets\" />\n");
|
|
|
|
- out.write("</Project>\n");
|
|
|
|
- out.close()
|
|
|
|
-
|
|
|
|
-def writeProject(out, solution_uuid, lib):
|
|
|
|
- out.write("Project(\"{"+str(solution_uuid)+"}\") = \""+lib["name"]+"\", \""+lib["name"]+"\\"+lib["name"]+".vcxproj\", \"{"+str(lib["uuid"])+"}\"\n")
|
|
|
|
- out.write("EndProject\n")
|
|
|
|
-
|
|
|
|
-def generatePlatformList(conf, ctx):
|
|
|
|
- add=[]
|
|
|
|
- for platform in conf["platforms"]:
|
|
|
|
- if platformSubseteqTest(ctx["platform"], platform):
|
|
|
|
- add.append(platform)
|
|
|
|
- add.sort(platformCompare)
|
|
|
|
- return add
|
|
|
|
-
|
|
|
|
-def generateConfiguration(ctx, includes, platform):
|
|
|
|
- conf={ "libraries": [], "tools": [], "platforms": {}, "mapping": {}, "format": {} }
|
|
|
|
- ctx["platform"]=platform
|
|
|
|
- for include in includes:
|
|
|
|
- parseConfiguration(conf, include, ctx)
|
|
|
|
- if ctx["platform"] not in conf["platforms"]:
|
|
|
|
- add=generatePlatformList(conf, ctx);
|
|
|
|
- if len(add)>0:
|
|
|
|
- conf["platforms"][ctx["platform"]]=conf["platforms"][add[0]]
|
|
|
|
- return conf
|
|
|
|
-
|
|
|
|
-def generateWin32(ctx, source):
|
|
|
|
- platform=ctx["platforms"][0]
|
|
|
|
- conf=generateConfiguration(ctx, [source], platform)
|
|
|
|
-# sys.stderr.write conf
|
|
|
|
- sys.stderr.write("generate win32 project")
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not isExcluded(conf, ctx, lib["name"]):
|
|
|
|
- generateVCXPROJ(conf, ctx, lib, "StaticLibrary")
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- if not isExcluded(conf, ctx, tool["name"]):
|
|
|
|
- generateVCXPROJ(conf, ctx, tool, "Application")
|
|
|
|
- solution_file=os.path.abspath("win32\\solution.sln")
|
|
|
|
- solution_uuid=uuid.uuid5(uuid.NAMESPACE_URL, solution_file)
|
|
|
|
- out=open(solution_file, "w")
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write("Microsoft Visual Studio Solution File, Format Version 11.00\n")
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not isExcluded(conf, ctx, lib["name"]):
|
|
|
|
- writeProject(out, solution_uuid, lib)
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- if not isExcluded(conf, ctx, tool["name"]):
|
|
|
|
- writeProject(out, solution_uuid, tool)
|
|
|
|
- out.write("\n")
|
|
|
|
- out.close()
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def writeSourceRules(conf, ctx, lib_type, out, lib, build_dir):
|
|
|
|
- dirs={}
|
|
|
|
- sources=gatherSources(conf, ctx, lib)
|
|
|
|
- out.write("objs_"+lib["name"]+"=\\\n")
|
|
|
|
- for source in sources:
|
|
|
|
- out.write(" $(BUILD_DIR)/"+os.path.splitext(source[0])[0]+".o\\\n")
|
|
|
|
- dirs[os.path.dirname(source[0])]=None
|
|
|
|
- out.write(" \n")
|
|
|
|
- out.write(lib["name"]+"_includes="+generateCPPFLAGS(conf, ctx, lib, build_dir)+"\n")
|
|
|
|
- out.write("\n")
|
|
|
|
- includes="$("+lib["name"]+"_includes)"
|
|
|
|
- lib_type_flags=""
|
|
|
|
- if lib_type=="shared":
|
|
|
|
- if platformSubseteqTest(ctx["platform"], "linux-*-gcc-*"):
|
|
|
|
- lib_type_flags=" -fPIC -DPIC"
|
|
|
|
- elif platformSubseteqTest(ctx["platform"], "darwin-*-gcc-*"):
|
|
|
|
- lib_type_flags=" -fno-common"
|
|
|
|
- # write special rules
|
|
|
|
- for source in sources:
|
|
|
|
- file=source[1]
|
|
|
|
- if "x" in file:
|
|
|
|
- special="-x "+file["x"]+" "
|
|
|
|
- out.write("$(BUILD_DIR)/"+os.path.splitext(source[0])[0]+".o: $(SRC_DIR)/"+source[0]+"\n")
|
|
|
|
- out.write("\t@mkdir -p $(dir $@)\n")
|
|
|
|
- out.write("\t$(CC) $(CFLAGS) $(CFLAGS_C) $(CPPFLAGS) "+special+includes+lib_type_flags+" -c \"$<\" -o \"$@\"\n")
|
|
|
|
- # write generic rules
|
|
|
|
- for dir in dirs:
|
|
|
|
- for ext in EXT_MAPPING:
|
|
|
|
- if EXT_MAPPING[ext]=='c' or EXT_MAPPING[ext]=='s':
|
|
|
|
- out.write("$(BUILD_DIR)/"+dir+"/%.o: $(SRC_DIR)/"+dir+"/%"+ext+"\n")
|
|
|
|
- out.write("\t@mkdir -p $(dir $@)\n")
|
|
|
|
- out.write("\t$(CC) $(CFLAGS) $(CFLAGS_C) $(CPPFLAGS) "+includes+lib_type_flags+" -c \"$<\" -o \"$@\"\n")
|
|
|
|
- out.write("\n")
|
|
|
|
- elif EXT_MAPPING[ext]=='cpp':
|
|
|
|
- out.write("$(BUILD_DIR)/"+dir+"/%.o: $(SRC_DIR)/"+dir+"/%"+ext+"\n")
|
|
|
|
- out.write("\t@mkdir -p $(dir $@)\n")
|
|
|
|
- out.write("\t$(CC) $(CFLAGS) $(CFLAGS_CPP) $(CPPFLAGS) "+includes+lib_type_flags+" -c \"$<\" -o \"$@\"\n")
|
|
|
|
- out.write("\n")
|
|
|
|
-
|
|
|
|
-def writeMakefileFlags(conf, ctx, out):
|
|
|
|
- platform=ctx["platform"]
|
|
|
|
- out.write("CC="+conf["platforms"][platform]["cc"]+"\n");
|
|
|
|
- out.write("AR="+conf["platforms"][platform]["ar"]+"\n");
|
|
|
|
- out.write("CFLAGS="+conf["platforms"][platform]["cflags"]+"\n")
|
|
|
|
- out.write("CFLAGS_C="+conf["platforms"][platform]["cflags_c"]+"\n")
|
|
|
|
- out.write("CFLAGS_CPP="+conf["platforms"][platform]["cflags_cpp"]+"\n")
|
|
|
|
- out.write("CPPFLAGS="+conf["platforms"][platform]["cppflags"]+"\n");
|
|
|
|
- out.write("LDFLAGS="+conf["platforms"][platform]["ldflags"]+"\n");
|
|
|
|
-
|
|
|
|
-def getSharedExt(conf, ctx):
|
|
|
|
- if platformSubseteqTest(ctx["platform"], "darwin-*-gcc-*"):
|
|
|
|
- return ".dylib"
|
|
|
|
- else:
|
|
|
|
- return ".so"
|
|
|
|
-
|
|
|
|
-def generateExtLDFlags(conf, ctx):
|
|
|
|
- ext_ldflags=""
|
|
|
|
- for dep_lib in conf["libraries"]:
|
|
|
|
- if dep_lib["name"] in ctx["externals"]:
|
|
|
|
- ext_lib=ctx["externals"][dep_lib["name"]]
|
|
|
|
- if "external" in ext_lib and ext_lib["external"]:
|
|
|
|
- if "ldflags" in ext_lib:
|
|
|
|
- ext_ldflags=ext_ldflags+" "+ext_lib["ldflags"]
|
|
|
|
- return ext_ldflags
|
|
|
|
-
|
|
|
|
-def generateLDFlags(conf, ctx, lib_type, initial_deps, exclude_deps, lib_form):
|
|
|
|
- ret=""
|
|
|
|
- deps=depClosure(conf, initial_deps, True)
|
|
|
|
- for dep in deps:
|
|
|
|
- if not(dep in exclude_deps):
|
|
|
|
- if lib_type=="static":
|
|
|
|
- ret=ret+" $(BUILD_DIR)/lib"+dep+".a"
|
|
|
|
- if lib_type=="shared":
|
|
|
|
- if lib_form:
|
|
|
|
- ret=ret+" -L$(BUILD_DIR) -l"+dep
|
|
|
|
- else:
|
|
|
|
- ret=ret+" $(BUILD_DIR)/lib"+dep+getSharedExt(conf, ctx)
|
|
|
|
-
|
|
|
|
- return ret
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def generateLibraryMakefile(conf, ctx, lib_type, lib, filename, build_dir, src_dir):
|
|
|
|
- sys.stderr.write("generating "+filename+"\n")
|
|
|
|
- if not os.path.exists(os.path.dirname(filename)):
|
|
|
|
- os.makedirs(os.path.dirname(filename))
|
|
|
|
- out=open(filename, "w")
|
|
|
|
- out.write("# Generated.\n")
|
|
|
|
- # compiler flags
|
|
|
|
- writeMakefileFlags(conf, ctx, out)
|
|
|
|
- out.write("BUILD_DIR=.\n")
|
|
|
|
- out.write("SRC_DIR="+src_dir+"\n")
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write(".PHONY: all clean\n")
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write("# library "+lib["name"]+"\n")
|
|
|
|
- out.write("all:")
|
|
|
|
- if lib_type=="static":
|
|
|
|
- out.write(" $(BUILD_DIR)/lib"+lib["name"]+".a")
|
|
|
|
- if lib_type=="shared":
|
|
|
|
- out.write(" $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx))
|
|
|
|
- out.write("\n\n")
|
|
|
|
- writeSourceRules(conf, ctx, lib_type, out, lib, build_dir)
|
|
|
|
- if lib_type=="static":
|
|
|
|
- out.write("$(BUILD_DIR)/lib"+lib["name"]+".a: $(objs_"+lib["name"]+")\n")
|
|
|
|
- out.write("\t$(AR) -rcs $(BUILD_DIR)/lib"+lib["name"]+".a $(objs_"+lib["name"]+")\n")
|
|
|
|
- out.write("\n")
|
|
|
|
- if lib_type=="shared":
|
|
|
|
- ld_deps=generateLDFlags(conf, ctx, lib_type, lib["deps"], [lib["name"]], True)+generateExtLDFlags(conf, ctx)
|
|
|
|
- out.write("$(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx)+": $(objs_"+lib["name"]+")\n")
|
|
|
|
- if platformSubseteqTest(ctx["platform"], "darwin-*-gcc-*"):
|
|
|
|
- out.write("\t$(CC) -dynamiclib -install_name lib"+lib["name"]+getSharedExt(conf, ctx)+" -o $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx)+" $(objs_"+lib["name"]+")"+ld_deps+"\n")
|
|
|
|
- else:
|
|
|
|
- out.write("\t$(CC) -shared -Wl,-soname,lib"+lib["name"]+getSharedExt(conf, ctx)+" -Wl,-z,defs -fPIC -o $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx)+" $(objs_"+lib["name"]+")"+ld_deps+" -lc\n")
|
|
|
|
- out.write("\tstrip --remove-section=.comment --remove-section=.note --strip-unneeded $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx))
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write("clean:\n")
|
|
|
|
- out.write("\trm -rf $(BUILD_DIR)/lib"+lib["name"]+".a $(BUILD_DIR)/lib"+lib["name"]+getSharedExt(conf, ctx)+" $(objs_"+lib["name"]+")\n")
|
|
|
|
- out.close()
|
|
|
|
-
|
|
|
|
-def generateLibraryInclude(conf, ctx, lib, filename, build_dir, src_dir):
|
|
|
|
- sys.stderr.write("generating "+filename+"\n")
|
|
|
|
- if not os.path.exists(os.path.dirname(filename)):
|
|
|
|
- os.makedirs(os.path.dirname(filename))
|
|
|
|
- ret=[]
|
|
|
|
- lib_deps=lib["deps"]
|
|
|
|
- lib_deps.append(lib["name"])
|
|
|
|
-# out.write("deps="+str(lib["deps"])+"\n");
|
|
|
|
- dep_closure=depClosure(conf, lib_deps, False)
|
|
|
|
- dep_dirs=gatherIncludeDirs(conf, ctx, dep_closure)
|
|
|
|
- for dep in dep_dirs:
|
|
|
|
- dep_dir=os.path.join(ctx["base"], str(dep))
|
|
|
|
- if dep_dir in conf["mapping"]:
|
|
|
|
- dep_dir=conf["mapping"][dep_dir]
|
|
|
|
- if dep_dir in conf["format"]:
|
|
|
|
- ln_src=os.path.join(build_dir, "include", os.path.relpath(conf["format"][dep_dir], ctx["base"]).format(platform="platform").replace(os.sep, "_"))
|
|
|
|
- ln_dst=os.path.join(src_dir, dep)
|
|
|
|
- if os.path.exists(ln_src):
|
|
|
|
- os.remove(ln_src)
|
|
|
|
- print "symlink("+ln_dst+", "+ln_src+")"+str(os.path.exists(ln_src))
|
|
|
|
- os.symlink(ln_dst, ln_src)
|
|
|
|
- ret.append(ln_src)
|
|
|
|
- else:
|
|
|
|
- ret.append(dep)
|
|
|
|
-
|
|
|
|
- out=open(filename, "w")
|
|
|
|
- for file in ret:
|
|
|
|
- out.write(file+"\n")
|
|
|
|
- out.close()
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def generateToolMakefile(conf, ctx, lib_type, tool, filename, build_dir, src_dir):
|
|
|
|
- sys.stderr.write("generating "+filename+"\n")
|
|
|
|
- if not os.path.exists(os.path.dirname(filename)):
|
|
|
|
- os.makedirs(os.path.dirname(filename))
|
|
|
|
- out=open(filename, "w")
|
|
|
|
- out.write("# Generated.\n")
|
|
|
|
- # compiler flags
|
|
|
|
- writeMakefileFlags(conf, ctx, out)
|
|
|
|
- out.write("BUILD_DIR=.\n")
|
|
|
|
- out.write("SRC_DIR="+src_dir+"\n")
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write(".PHONY: all clean\n")
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write("# tool "+tool["name"]+"\n")
|
|
|
|
- out.write("all: $(BUILD_DIR)/"+ tool["name"]+"\n\n")
|
|
|
|
- writeSourceRules(conf, ctx, "static", out, tool, build_dir)
|
|
|
|
- out.write(tool["name"]+"_ld="+generateLDFlags(conf, ctx, lib_type, tool["deps"], [], False)+"\n")
|
|
|
|
-# deps=depClosure(conf, tool["deps"], True)
|
|
|
|
-# for dep in deps:
|
|
|
|
-# if lib_type=="static":
|
|
|
|
-# out.write(" $(BUILD_DIR)/lib"+ dep +".a")
|
|
|
|
-# if lib_type=="shared":
|
|
|
|
-# out.write(" $(BUILD_DIR)/lib"+ dep +getSharedExt(conf, ctx))
|
|
|
|
-# out.write("\n")
|
|
|
|
- ext_ldflags=generateExtLDFlags(conf, ctx)
|
|
|
|
-# ext_ldflags=""
|
|
|
|
-# for dep_lib in conf["libraries"]:
|
|
|
|
-# if dep_lib["name"] in ctx["externals"]:
|
|
|
|
-# ext_lib=ctx["externals"][dep_lib["name"]]
|
|
|
|
-# if "external" in ext_lib and ext_lib["external"]:
|
|
|
|
-# if "ldflags" in ext_lib:
|
|
|
|
-# ext_ldflags=ext_ldflags+" "+ext_lib["ldflags"]
|
|
|
|
-
|
|
|
|
- out.write("$(BUILD_DIR)/"+tool["name"]+": $(objs_"+tool["name"]+") $("+tool["name"]+"_ld)\n")
|
|
|
|
- static_flag=""
|
|
|
|
- if lib_type=="static" and platformSubseteqTest(ctx["platform"], "linux-*-gcc-*"):
|
|
|
|
- static_flag=" --static"
|
|
|
|
- out.write("\t$(CC) $(CFLAGS) $(CPPFLAGS) -o $(BUILD_DIR)/"+tool["name"]+" $(objs_"+tool["name"]+") "+generateLDFlags(conf, ctx, lib_type, tool["deps"], [], True)+ ext_ldflags+" $(LDFLAGS)\n")
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write("clean:\n")
|
|
|
|
- out.write("\trm -f $(BUILD_DIR)/"+tool["name"]+" $(objs_"+tool["name"]+")\n")
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def generateTypedMakefile(conf, ctx, lib_type):
|
|
|
|
- obj_dir=os.path.join("build", ctx["platform"], lib_type)
|
|
|
|
- filename=os.path.join(obj_dir, "Makefile")
|
|
|
|
- sys.stderr.write("generating "+filename+"\n")
|
|
|
|
- if not os.path.exists(os.path.dirname(filename)):
|
|
|
|
- os.makedirs(os.path.dirname(filename))
|
|
|
|
- out=open(filename, "w")
|
|
|
|
- out.write("# Generated.\n")
|
|
|
|
-
|
|
|
|
- # generate phony targets
|
|
|
|
- out.write(".PHONY: all clean tools dep")
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not lib["external"]:
|
|
|
|
- out.write(" "+lib["name"])
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- out.write(" "+tool["name"])
|
|
|
|
- out.write("\n")
|
|
|
|
- # all
|
|
|
|
- out.write("all:")
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not lib["external"]:
|
|
|
|
- out.write(" "+lib["name"])
|
|
|
|
- out.write(" tools\n")
|
|
|
|
- # tools
|
|
|
|
- out.write("tools:")
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- out.write(" "+tool["name"])
|
|
|
|
- out.write("\n")
|
|
|
|
-
|
|
|
|
- # generate libs
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not lib["external"]:
|
|
|
|
- makefile=os.path.join(obj_dir, "Makefile."+lib["name"])
|
|
|
|
- generateLibraryMakefile(conf, ctx, lib_type, lib, makefile, obj_dir, os.path.join("..", "..", ".."))
|
|
|
|
- libincludefile=os.path.join(obj_dir, "include", lib["name"]+".inc")
|
|
|
|
- generateLibraryInclude(conf, ctx, lib, libincludefile, obj_dir, os.path.join("..", "..", "..", ".."))
|
|
|
|
- out.write(lib["name"]+":")
|
|
|
|
- deps=depClosure(conf, lib["deps"], True)
|
|
|
|
- for dep in deps:
|
|
|
|
- if lib["name"]!=dep:
|
|
|
|
- out.write(" "+dep)
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write("\t$(MAKE) -f "+"Makefile."+lib["name"]+"\n\n")
|
|
|
|
-
|
|
|
|
- # generate tools
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- makefile=os.path.join(obj_dir, "Makefile."+tool["name"])
|
|
|
|
- generateToolMakefile(conf, ctx, lib_type, tool, makefile, obj_dir, os.path.join("..", "..", ".."))
|
|
|
|
- deps=depClosure(conf, tool["deps"], True)
|
|
|
|
- out.write(tool["name"]+":")
|
|
|
|
- for dep in deps:
|
|
|
|
- if tool["name"]!=dep:
|
|
|
|
- out.write(" "+dep)
|
|
|
|
- out.write("\n")
|
|
|
|
- out.write("\t$(MAKE) -f "+"Makefile."+ tool["name"]+"\n\n")
|
|
|
|
-
|
|
|
|
- out.write("clean:\n")
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not lib["external"]:
|
|
|
|
- out.write("\t$(MAKE) -f "+"Makefile."+lib["name"]+" clean\n")
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- out.write("\t$(MAKE) -f "+"Makefile."+tool["name"]+" clean\n")
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-# out.write("dep:\n")
|
|
|
|
-# for lib in conf["libraries"]:
|
|
|
|
-# generateDEPS(conf, ctx, lib, out, obj_dir, generateCPPFLAGS(conf, ctx, lib), filename)
|
|
|
|
-# for tool in conf["tools"]:
|
|
|
|
-# generateDEPS(conf, ctx, tool, out, obj_dir, generateCPPFLAGS(conf, ctx, tool), filename)
|
|
|
|
-
|
|
|
|
- out.write("package: all\n")
|
|
|
|
- out.write("\tcd ../../.. && ./generate.py --include Makefile.xml");
|
|
|
|
- for ext_lib in ctx["externals"]:
|
|
|
|
- if ctx["externals"][ext_lib]["external"]:
|
|
|
|
- name=ext_lib
|
|
|
|
- if "xml"==ext_lib:
|
|
|
|
- name="libxml"
|
|
|
|
- out.write(" --with-"+name+"=yes")
|
|
|
|
- if "cppflags" in ctx["externals"][ext_lib]:
|
|
|
|
- out.write(" --with-"+name+"-cppflags=\""+ctx["externals"][ext_lib]["cppflags"]+"\"")
|
|
|
|
- if "ldflags" in ctx["externals"][ext_lib]:
|
|
|
|
- out.write(" --with-"+name+"-ldflags=\""+ctx["externals"][ext_lib]["ldflags"]+"\"")
|
|
|
|
- out.write(" --package package_"+lib_type+".zip --type "+lib_type)
|
|
|
|
- out.write(" --config-dir "+ctx["config"]+" "+ctx["platform"])
|
|
|
|
- out.write("\n")
|
|
|
|
-
|
|
|
|
- obj_dir=os.path.join(ctx["base"], "build", ctx["platform"], lib_type)
|
|
|
|
- tool_ext=""
|
|
|
|
- if lib_type=="static":
|
|
|
|
- lib_ext=".a"
|
|
|
|
- else:
|
|
|
|
- lib_ext=getSharedExt(conf, ctx)
|
|
|
|
- lib_prefix="lib"
|
|
|
|
- base="$(DESTDIR)/usr/"
|
|
|
|
- out.write("install: all\n")
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not lib["external"] and not isExcluded(conf, ctx, lib["name"]):
|
|
|
|
- for include in lib["header"]["files"]:
|
|
|
|
- if None!=include["install"]:
|
|
|
|
- target=base+"include/"
|
|
|
|
- if len(include["install"])>0:
|
|
|
|
- target=target+include["install"]+"/"
|
|
|
|
- target=target+os.path.split(include["path"])[1]
|
|
|
|
- out.write("\t@mkdir -p "+os.path.dirname(target)+"\n")
|
|
|
|
- out.write("\t@cp "+include["path"]+" "+target+"\n")
|
|
|
|
- target=base+"lib/"+lib_prefix+lib["name"]+lib_ext
|
|
|
|
- out.write("\t@mkdir -p "+os.path.dirname(target)+"\n")
|
|
|
|
- if lib_type=="shared":
|
|
|
|
- out.write("\t@cp "+os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext)+" "+target+".1\n")
|
|
|
|
- out.write("\tldconfig -v -n "+os.path.dirname(target)+"\n")
|
|
|
|
- else:
|
|
|
|
- out.write("\t@cp "+os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext)+" "+target+"\n")
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- if not isExcluded(conf, ctx, tool["name"]):
|
|
|
|
- target=base+"bin/"+tool["name"]+tool_ext
|
|
|
|
- out.write("\t@mkdir -p "+os.path.dirname(target)+"\n")
|
|
|
|
- out.write("\t@cp "+os.path.join(obj_dir, tool["name"]+tool_ext)+" "+target+"\n")
|
|
|
|
- target=base+"lib/pkgconfig/libopc.pc"
|
|
|
|
- out.write("\t@mkdir -p "+os.path.dirname(target)+"\n")
|
|
|
|
- out.write("\t@cp "+os.path.join(ctx["base"], "config", "libopc.pc")+" "+target+"\n")
|
|
|
|
- out.close()
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def generateTypedMakefiles(ctx, source, lib_types):
|
|
|
|
- for platform in ctx["platforms"]:
|
|
|
|
- conf=generateConfiguration(ctx, [source], platform)
|
|
|
|
- if ctx["platform"] in conf["platforms"]:
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- generateTypedMakefile(conf, ctx, lib_type)
|
|
|
|
- else:
|
|
|
|
- parseError("platform "+ctx["platform"]+" is unknown.")
|
|
|
|
- sys.stderr.write("available platforms:");
|
|
|
|
- for platform in conf["platforms"]:
|
|
|
|
- sys.stderr.write(platform+"\n")
|
|
|
|
- out=open("Makefile", "w")
|
|
|
|
- out.write(".PHONY: all clean");
|
|
|
|
- for platform in ctx["platforms"]:
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- out.write(" "+platform+"."+lib_type);
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- out.write(" "+lib_type);
|
|
|
|
- out.write("\n");
|
|
|
|
- out.write("all:");
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- out.write(" "+lib_type);
|
|
|
|
- out.write("\n");
|
|
|
|
-
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- out.write(lib_type+":");
|
|
|
|
- for platform in ctx["platforms"]:
|
|
|
|
- out.write(" "+platform+"."+lib_type);
|
|
|
|
- out.write("\n");
|
|
|
|
-
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- for platform in ctx["platforms"]:
|
|
|
|
- out.write(platform+"."+lib_type+": build"+os.sep+platform+os.sep+lib_type+os.sep+"Makefile\n");
|
|
|
|
- out.write("\t@$(MAKE) -C build"+os.sep+platform+os.sep+lib_type+"\n");
|
|
|
|
- out.write("clean:\n")
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- for platform in ctx["platforms"]:
|
|
|
|
- out.write("\t@$(MAKE) -C build"+os.sep+platform+os.sep+lib_type+" clean\n");
|
|
|
|
- out.write("package:\n")
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- for platform in ctx["platforms"]:
|
|
|
|
- out.write("\t@$(MAKE) -C build"+os.sep+platform+os.sep+lib_type+" package\n")
|
|
|
|
- out.write("install:\n")
|
|
|
|
- for lib_type in lib_types:
|
|
|
|
- for platform in ctx["platforms"]:
|
|
|
|
- out.write("\t@$(MAKE) -C build"+os.sep+platform+os.sep+lib_type+" install\n")
|
|
|
|
- out.close()
|
|
|
|
-
|
|
|
|
-def dumpEnvironment(ctx, includes, platform):
|
|
|
|
- conf=generateConfiguration(ctx, includes, platform)
|
|
|
|
- if platform in conf["platforms"]:
|
|
|
|
- p=conf["platforms"][platform]
|
|
|
|
-# print(str(p))
|
|
|
|
- host=""
|
|
|
|
- if "host" in p:
|
|
|
|
- host="HOST=\""+p["host"]+"\" "
|
|
|
|
- sys.stdout.write("export CC=\""+p["cc"]+"\" "+
|
|
|
|
- "export AR=\""+p["ar"]+"\" "+
|
|
|
|
- "export LD=\""+p["ld"]+"\" "
|
|
|
|
- "export CPPFLAGS=\""+p["cppflags"]+"\" "
|
|
|
|
- "export CFLAGS=\""+p["cflags"]+"\" "+
|
|
|
|
- host
|
|
|
|
- )
|
|
|
|
- else:
|
|
|
|
- parseError("platform "+platform+" is unknown.")
|
|
|
|
- sys.stderr.write("available platforms:");
|
|
|
|
- for platform in conf["platforms"]:
|
|
|
|
- sys.stderr.write(platform)
|
|
|
|
-
|
|
|
|
-def set_external_flag(ctx, lib, flag, value):
|
|
|
|
-# sys.stderr.write("SETTING "+lib+" "+flag+" "+str(value)+"\n")
|
|
|
|
- if lib in ctx["externals"]:
|
|
|
|
- ctx["externals"][lib][flag]=value
|
|
|
|
- else:
|
|
|
|
- ctx["externals"][lib]={flag: value}
|
|
|
|
-
|
|
|
|
-def is_external(ctx, lib):
|
|
|
|
- if lib in ctx["externals"]:
|
|
|
|
- if "external" in ctx["externals"][lib]:
|
|
|
|
- return ctx["externals"][lib]["external"]
|
|
|
|
- else:
|
|
|
|
- return False
|
|
|
|
- else:
|
|
|
|
- return False
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def generateZipPackage(ctx, source, lib_type, install_zip):
|
|
|
|
- zip=zipfile.ZipFile(install_zip, 'w', zipfile.ZIP_DEFLATED)
|
|
|
|
- base=os.path.splitext(install_zip)[0]+"/"
|
|
|
|
- platform=ctx["platforms"][0]
|
|
|
|
- conf=generateConfiguration(ctx, [source], platform)
|
|
|
|
- if platformSubseteqTest(ctx["platforms"][0], "win32-*-*"):
|
|
|
|
- obj_dir=os.path.join("win32", ctx["platform"].split('-')[1])
|
|
|
|
- tool_ext=".exe"
|
|
|
|
- lib_exts=[".lib"]
|
|
|
|
- if (lib_type=="shared"):
|
|
|
|
- shared_exts.append(".dll")
|
|
|
|
- lib_prefix=""
|
|
|
|
- else:
|
|
|
|
- obj_dir=os.path.join("build", ctx["platform"], lib_type)
|
|
|
|
- tool_ext=""
|
|
|
|
- if lib_type=="shared":
|
|
|
|
- lib_exts=[".dylib"]
|
|
|
|
- else:
|
|
|
|
- lib_exts=[".a"]
|
|
|
|
- lib_prefix="lib"
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not lib["external"] and not isExcluded(conf, ctx, lib["name"]):
|
|
|
|
- for include in lib["header"]["files"]:
|
|
|
|
- if None!=include["install"]:
|
|
|
|
- target=base+"include/"
|
|
|
|
- if len(include["install"])>0:
|
|
|
|
- target=target+include["install"]+"/"
|
|
|
|
- target=target+os.path.split(include["path"])[1]
|
|
|
|
- zip.write(include["path"], target)
|
|
|
|
- for lib_ext in lib_exts:
|
|
|
|
- target=base+"lib/"+lib_prefix+lib["name"]+lib_ext
|
|
|
|
-# print "ADD "+os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext)
|
|
|
|
- zip.write(os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext), target)
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- if not isExcluded(conf, ctx, tool["name"]):
|
|
|
|
- target=base+"bin/"+tool["name"]+tool_ext
|
|
|
|
- zip.write(os.path.join(obj_dir, tool["name"]+tool_ext), target)
|
|
|
|
- zip.write(os.path.join("third_party", "LICENSE"), base+"/LICENSE.THIRD_PARTY")
|
|
|
|
- zip.write("LICENSE", base+"/LICENSE")
|
|
|
|
- zip.close()
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-def installFiles(ctx, source, lib_type, base):
|
|
|
|
- copy_ctx=None
|
|
|
|
- platform=ctx["platforms"][0]
|
|
|
|
- conf=generateConfiguration(ctx, [source], platform)
|
|
|
|
- if platformSubseteqTest(ctx["platforms"][0], "win32-*-*"):
|
|
|
|
- obj_dir=os.path.join("win32", ctx["platform"].split('-')[1])
|
|
|
|
- tool_ext=".exe"
|
|
|
|
- lib_exts=[".lib"]
|
|
|
|
- lib_prefix=""
|
|
|
|
- else:
|
|
|
|
- obj_dir=os.path.join("build", ctx["platform"], lib_type)
|
|
|
|
- tool_ext=""
|
|
|
|
- lib_exts=[".a", getSharedExt(conf, ctx)]
|
|
|
|
- lib_prefix="lib"
|
|
|
|
- for lib in conf["libraries"]:
|
|
|
|
- if not lib["external"] and not isExcluded(conf, ctx, lib["name"]):
|
|
|
|
- for include in lib["header"]["files"]:
|
|
|
|
- if None!=include["install"]:
|
|
|
|
- target=base+"include/"
|
|
|
|
- if len(include["install"])>0:
|
|
|
|
- target=target+include["install"]+"/"
|
|
|
|
- target=target+os.path.split(include["path"])[1]
|
|
|
|
- copyFile(copy_ctx, include["path"], target)
|
|
|
|
- for lib_ext in lib_exts:
|
|
|
|
- target=base+"lib/"+lib_prefix+lib["name"]+lib_ext
|
|
|
|
- copyFile(copy_ctx, os.path.join(obj_dir, lib_prefix+lib["name"]+lib_ext), target)
|
|
|
|
- for tool in conf["tools"]:
|
|
|
|
- if not isExcluded(conf, ctx, tool["name"]):
|
|
|
|
- target=base+"bin/"+tool["name"]+tool_ext
|
|
|
|
- copyFile(copy_ctx, os.path.join(obj_dir, tool["name"]+tool_ext), target)
|
|
|
|
- copyFile(copy_ctx, os.path.join("third_party", "LICENSE"), base+"/LICENSE.THIRD_PARTY")
|
|
|
|
- copyFile(copy_ctx, "LICENSE", base+"/LICENSE")
|
|
|
|
-
|
|
|
|
-def usage():
|
|
|
|
- print("usage:")
|
|
|
|
- print(" generate [--include \"Makefile.xml\"]")
|
|
|
|
- print(" [--config-dir \"config/\"]")
|
|
|
|
- print(" [--print-env \"linux-release-gcc\"]")
|
|
|
|
- print(" [--package \"xyz.zip/\"]")
|
|
|
|
-
|
|
|
|
-if __name__ == "__main__":
|
|
|
|
- try:
|
|
|
|
- opts, args = getopt.getopt(sys.argv[1:], "h", ["help", "include=", "config-dir=", "print-env=",
|
|
|
|
- "package=", "install=",
|
|
|
|
- "with-zlib-cppflags=", "with-zlib-ldflags=", "with-zlib=",
|
|
|
|
- "with-libxml-cppflags=", "with-libxml-ldflags=", "with-libxml=",
|
|
|
|
- "type="])
|
|
|
|
- except getopt.GetoptError, err:
|
|
|
|
- # print help information and exit:
|
|
|
|
- print str(err) # will print something like "option -a not recognized"
|
|
|
|
- usage()
|
|
|
|
- sys.exit(2)
|
|
|
|
- ctx={ "base": os.path.abspath(os.curdir), "root": os.path.abspath(os.curdir), "platform": "?-?-?", "platforms": [], "externals": {} }
|
|
|
|
- ctx["config"]=ctx["base"]
|
|
|
|
- includes=[]
|
|
|
|
- dump_env=[]
|
|
|
|
- install_zip=None
|
|
|
|
- target_type="static"
|
|
|
|
- for o, a in opts:
|
|
|
|
- if o in ("-h", "--help"):
|
|
|
|
- usage()
|
|
|
|
- sys.exit(0)
|
|
|
|
- elif o in ("--include"):
|
|
|
|
- includes.append(a)
|
|
|
|
- elif o in ("--config-dir"):
|
|
|
|
- ctx["config"]=os.path.join(ctx["base"], a)
|
|
|
|
- elif o in ("--print-env"):
|
|
|
|
- args=[]
|
|
|
|
- dump_env=[a]
|
|
|
|
- elif o in ("--package"):
|
|
|
|
- install_zip=a
|
|
|
|
- elif o in ("--install"):
|
|
|
|
- install_files=a
|
|
|
|
- elif o in ("--with-zlib"):
|
|
|
|
- set_external_flag(ctx, "zlib", "external", "yes"==a)
|
|
|
|
- elif o in ("--with-zlib-cppflags"):
|
|
|
|
- set_external_flag(ctx, "zlib", "cppflags", a)
|
|
|
|
- elif o in ("--with-zlib-ldflags"):
|
|
|
|
- set_external_flag(ctx, "zlib", "ldflags", a)
|
|
|
|
- elif o in ("--with-libxml"):
|
|
|
|
- set_external_flag(ctx, "xml", "external", "yes"==a)
|
|
|
|
- elif o in ("--with-libxml-cppflags"):
|
|
|
|
- set_external_flag(ctx, "xml", "cppflags", a)
|
|
|
|
- elif o in ("--with-libxml-ldflags"):
|
|
|
|
- set_external_flag(ctx, "xml", "ldflags", a)
|
|
|
|
- elif o in ("--type"):
|
|
|
|
- target_type=a
|
|
|
|
-
|
|
|
|
- for platform in args:
|
|
|
|
- ctx["platforms"].append(platform)
|
|
|
|
-
|
|
|
|
- if 1==len(ctx["platforms"]) and None!=install_zip and 1==len(includes):
|
|
|
|
- ctx["root"]=os.path.abspath(os.path.split(includes[0])[0])
|
|
|
|
- generateZipPackage(ctx, includes[0], target_type, install_zip)
|
|
|
|
- elif 1==len(ctx["platforms"]) and platformSubseteqTest(ctx["platforms"][0], "win32-*-msvc-*") and 1==len(includes):
|
|
|
|
- ctx["root"]=os.path.abspath(os.path.split(includes[0])[0])
|
|
|
|
- generateWin32(ctx, includes[0])
|
|
|
|
- else:
|
|
|
|
- if is_external(ctx, "zlib") and is_external(ctx, "xml"):
|
|
|
|
- lib_types=["static", "shared"]
|
|
|
|
- else:
|
|
|
|
- lib_types=["static"]
|
|
|
|
- if not os.path.exists("build"):
|
|
|
|
- os.makedirs("build")
|
|
|
|
- f=open(os.path.join("build", "configure.ctx"), "w")
|
|
|
|
- f.write(str(ctx))
|
|
|
|
- f.close()
|
|
|
|
- for include in includes:
|
|
|
|
- ctx["root"]=os.path.abspath(os.path.split(include)[0])
|
|
|
|
- generateTypedMakefiles(ctx, include, lib_types)
|
|
|
|
-
|
|
|
|
- for platform in dump_env:
|
|
|
|
- dumpEnvironment(ctx, includes, platform)
|
|
|
|
-
|
|
|