1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
#
# Rules for generated source files
#
# Hand-build deftwmrc.c
set(defc ${CMAKE_CURRENT_BINARY_DIR}/deftwmrc.c)
set(mkdefc ${TOOLS}/mk_deftwmrc.sh)
add_custom_command(OUTPUT ${defc}
DEPENDS system.ctwmrc ${mkdefc}
COMMAND ${mkdefc} ${CMAKE_CURRENT_SOURCE_DIR}/system.ctwmrc > ${defc}
)
# Hand-build ctwm_atoms.[ch]
set(ctwm_atoms ctwm_atoms.h ctwm_atoms.c)
add_custom_command(OUTPUT ${ctwm_atoms}
DEPENDS ctwm_atoms.in ${TOOLS}/mk_atoms.sh
COMMAND ${TOOLS}/mk_atoms.sh ${CMAKE_CURRENT_SOURCE_DIR}/ctwm_atoms.in ctwm_atoms CTWM
)
# Generate up the event names lookup source
set(en_list ${CMAKE_CURRENT_SOURCE_DIR}/event_names.list)
set(en_out ${CMAKE_CURRENT_BINARY_DIR}/event_names_table.h)
set(en_mk ${TOOLS}/mk_event_names.sh)
add_custom_command(OUTPUT ${en_out}
DEPENDS ${en_list} ${en_mk}
COMMAND ${en_mk} ${en_list} > ${en_out}
)
# Have to manually add this, or cmake won't notice that it's needed in
# time to make it.
#set_source_files_properties(event_names.c OBJECT_DEPENDS ${en_out})
# This also seems a blessed hackaround, and avoids having to encode the
# knowledge of what files #include it.
list(APPEND CTWMSRC ${CMAKE_CURRENT_BINARY_DIR}/event_names_table.h)
# Create function bits
set(fd_list ${CMAKE_CURRENT_SOURCE_DIR}/functions_defs.list)
set(fd_mk ${TOOLS}/mk_function_bits.sh)
set(fd_h ${CMAKE_CURRENT_BINARY_DIR}/functions_defs.h)
set(fdd_h ${CMAKE_CURRENT_BINARY_DIR}/functions_deferral.h)
set(fpt_h ${CMAKE_CURRENT_BINARY_DIR}/functions_parse_table.h)
set(fde_h ${CMAKE_CURRENT_BINARY_DIR}/functions_dispatch_execution.h)
add_custom_command(
OUTPUT ${fd_h} ${fdd_h} ${fpt_h} ${fde_h}
DEPENDS ${fd_list} ${fd_mk}
COMMAND ${fd_mk} ${fd_list} ${CMAKE_CURRENT_BINARY_DIR}
)
list(APPEND CTWMSRC ${fd_h} ${fdd_h} ${fpt_h} ${fde_h})
# Setup config header file
configure_file(ctwm_config.h.in ctwm_config.h ESCAPE_QUOTES)
# Fill in version info
# Need the VCS bits; add a guard here to prevent dev screwups when
# working on the build system.
if(NOT VCS_CHECKS_RUN)
message(FATAL_ERROR "Internal error: VCS checks not done yet!")
endif()
# Building the version.c file happens in 2 steps. First, an original
# source file (${version_c_src}) is processed with tools/mk_version_in.sh
# to write in the ctwm version info found in the VERSION file in the root
# of the tree. That's written to an intermediate file (${version_c_in}).
# Secondly, the intermediate file is processed to store up info about the
# VCS revision being built from, into the final file (${version_c}) which
# is actually compiled.
#
# A special case occurs when there's no VCS info we can find to work
# with, AND we have a pregen'd .in file (${vresion_c_gen}); this is
# commonly the case with a release tarball, where part of the release
# building process pre-stashes the bzr revision info. In that case, we
# swap the original (${version_c_src}) to point to the pregen'd file
# (which already has the VCS info), and make the second step just cp the
# intermediate file over.
set(version_c_src ${CMAKE_CURRENT_SOURCE_DIR}/version.c.in)
set(version_c_in ${CMAKE_CURRENT_BINARY_DIR}/version.c.in)
set(version_c ${CMAKE_CURRENT_BINARY_DIR}/version.c)
# Maybe a pregen'd
set(version_c_gen ${GENSRCDIR}/version.c.in)
# Override
if(FORCE_PREGEN_FILES)
set(HAS_BZR 0)
set(HAS_GIT 0)
endif()
# Now, what's our process for going from the intermediate .c.in file to
# the final .c with the VCS revision info added? This is the 2nd step in
# the process, but we describe it first here so we can change where
# ${version_c_src} points if necessary.
if(IS_BZR_CO AND HAS_BZR)
# We're in a bzr tree, so write in the bzr revision info
set(rw_ver_bzr "${TOOLS}/rewrite_version_bzr.sh")
add_custom_command(OUTPUT ${version_c}
DEPENDS ${version_c_in} ${BZR_DIRSTATE_FILE} ${rw_ver_bzr}
COMMAND env BZR_CMD=${BZR_CMD} ${rw_ver_bzr} < ${version_c_in} > ${version_c}
COMMENT "Generating version.c from current WT state."
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
)
elseif(IS_GIT_CO AND HAS_GIT)
# We're in a git tree, so write in the git revision info
set(rw_ver_git "${TOOLS}/rewrite_version_git.sh")
add_custom_command(OUTPUT ${version_c}
DEPENDS ${version_c_in} ${GIT_INDEX_FILE} ${rw_ver_git}
COMMAND ${rw_ver_git} < ${version_c_in} > ${version_c}
COMMENT "Generating version.c from current git state."
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
)
elseif(EXISTS ${version_c_gen})
# There's a prebuilt one to use; commonly this means we're building
# from a release tarball, and it includes pre-stashed bzr revision
# info about the release. So, in this case, we replace the original
# source with our pregen'd one (which already has the info in it),
# and just use 'cp' to turn the intermediate .c.in into the final .c.
set(version_c_src ${version_c_gen})
add_custom_command(OUTPUT ${version_c}
DEPENDS ${version_c_in}
COMMAND cp ${version_c_in} ${version_c}
COMMENT "Using pregenerated version.c."
)
else()
# We've got nothing at all, so just NULL out the VCS info; it's all
# we can do.
add_custom_command(OUTPUT ${version_c}
DEPENDS ${version_c_in}
COMMAND sed -e 's/%%VCSTYPE%%/NULL/' -e 's/%%REVISION%%/NULL/'
< ${version_c_in} > ${version_c}
COMMENT "Using null version.c."
)
endif()
# Now handle the first step; turning the original source .c.in into the
# intermediate .c.in with the ctwm version written in. That's _usually_
# starting with the version.c.in in the source tree, but in the "no VCS
# info, but we have a pregen'd gen/version.c to use" case above it's the
# pregen'd file.
add_custom_command(OUTPUT ${version_c_in}
DEPENDS ${version_c_src} ${CMAKE_CURRENT_SOURCE_DIR}/VERSION
DEPENDS ${TOOLS}/mk_version_in.sh
COMMAND ${TOOLS}/mk_version_in.sh ${version_c_src} > ${version_c_in}
COMMENT "Writing version info into version.c.in"
)
# Setup a 'version' binary build tool too, for easily printing bits or
# wholes of our version.
#
# Not currently being used, but left as an example of possibilities. If
# we need the version in the build process, we'll get it from the
# ${ctwm_version_*} vars now.
#add_executable(version ${version_c})
#set_target_properties(version PROPERTIES COMPILE_FLAGS "-DBUILD_VERSION_BIN")
|