source/build/smb_build/output.pm

   1 ###########################################################
   2 ### SMB Build System                                    ###
   3 ### - the output generating functions                   ###
   4 ###                                                     ###
   5 ###  Copyright (C) Stefan (metze) Metzmacher 2004       ###
   6 ###  Released under the GNU GPL                         ###
   7 ###########################################################
   8
   9 package output;
  10 use strict;
  11
  12 sub _generate_ext_libs($)
  13 {
  14         my $CTX = shift;
  15
  16         #
  17         # loop over all binaries
  18         #
  19         foreach my $key (sort keys %{$CTX->{DEPEND}{EXT_LIBS}}) {
  20                 my $NAME = $CTX->{INPUT}{EXT_LIBS}{$key}{NAME};
  21
  22                 #
  23                 # set the lists
  24                 #
  25                 $CTX->{OUTPUT}{EXT_LIBS}{$key}{NAME} = $NAME;
  26                 @{$CTX->{OUTPUT}{EXT_LIBS}{$key}{LIBS}} = @{$CTX->{DEPEND}{EXT_LIBS}{$key}{LIBS}};
  27                 @{$CTX->{OUTPUT}{EXT_LIBS}{$key}{CFLAGS}} = @{$CTX->{DEPEND}{EXT_LIBS}{$key}{CFLAGS}};
  28                 @{$CTX->{OUTPUT}{EXT_LIBS}{$key}{CPPFLAGS}} = @{$CTX->{DEPEND}{EXT_LIBS}{$key}{CPPFLAGS}};
  29                 @{$CTX->{OUTPUT}{EXT_LIBS}{$key}{LDFLAGS}} = @{$CTX->{DEPEND}{EXT_LIBS}{$key}{LDFLAGS}};
  30         }
  31
  32         return;
  33 }
  34
  35 sub _generate_subsystems($)
  36 {
  37         my $CTX = shift;
  38
  39         #
  40         # loop over all subsystems
  41         #
  42         foreach my $key (sort keys %{$CTX->{DEPEND}{SUBSYSTEMS}}) {
  43                 my $NAME = $CTX->{INPUT}{SUBSYSTEMS}{$key}{NAME};
  44                 my @OBJ_LIST = @{$CTX->{DEPEND}{SUBSYSTEMS}{$key}{OBJ_LIST}};
  45
  46                 if ($CTX->{INPUT}{SUBSYSTEMS}{$key}{NOPROTO} ne "YES") {
  47                         push(@{$CTX->{OUTPUT}{PROTO}{OBJ_LIST}},"\$(SUBSYSTEM_$key\_OBJS)");
  48                 }
  49
  50                 #
  51                 # set the lists
  52                 #
  53                 $CTX->{OUTPUT}{SUBSYSTEMS}{$key}{NAME} = $NAME;
  54                 @{$CTX->{OUTPUT}{SUBSYSTEMS}{$key}{OBJ_LIST}} = @OBJ_LIST;
  55         }
  56
  57         return;
  58 }
  59
  60 sub _generate_shared_modules($)
  61 {
  62         my $CTX = shift;
  63
  64         #
  65         # loop over all shared modules
  66         #
  67         foreach my $key (sort keys %{$CTX->{DEPEND}{SHARED_MODULES}}) {
  68                 my $NAME = $CTX->{INPUT}{MODULES}{$key}{NAME};
  69                 my @OBJ_LIST = ();
  70                 #
  71                 my $MODULE = $NAME.".so";
  72                 my @DEPEND_LIST = ("\$(MODULE_$NAME\_OBJS)");
  73                 my @LINK_LIST = ("\$(MODULE_$NAME\_OBJS)");
  74                 my @LINK_FLAGS = ();
  75
  76                 push(@{$CTX->{OUTPUT}{PROTO}{OBJ_LIST}},"\$(MODULE_$key\_OBJS)");
  77                 push(@{$CTX->{OUTPUT}{TARGETS}{ALL}{DEPEND_LIST}},"bin/$MODULE");
  78
  79                 push(@OBJ_LIST,@{$CTX->{INPUT}{MODULES}{$key}{INIT_OBJ_FILES}});
  80                 push(@OBJ_LIST,@{$CTX->{INPUT}{MODULES}{$key}{ADD_OBJ_FILES}});
  81
  82                 foreach my $elem (@{$CTX->{DEPEND}{SHARED_MODULES}{$key}{SUBSYSTEMS_LIST}}) {
  83                         if (!defined($CTX->{DEPEND}{SUBSYSTEMS}{$elem})) {
  84                                 die("Shared Module[$NAME] depends on unknown Subsystem[$elem]!\n");
  85                         }
  86                         push(@DEPEND_LIST,"\$(SUBSYSTEM_$elem\_OBJS)");
  87                         push(@LINK_LIST,"\$(SUBSYSTEM_$elem\_OBJS)");
  88                 }
  89
  90                 foreach my $elem (@{$CTX->{DEPEND}{SHARED_MODULES}{$key}{LIBRARIES_LIST}}) {
  91                         if (!defined($CTX->{DEPEND}{EXT_LIBS}{$elem})) {
  92                                 die("Share Module[$NAME] depends on unknown External Library[$elem]!\n");
  93                         }
  94                         push(@LINK_LIST,@{$CTX->{DEPEND}{EXT_LIBS}{$elem}{LIBS}});
  95                         push(@LINK_FLAGS,@{$CTX->{DEPEND}{EXT_LIBS}{$elem}{LDFLAGS}});
  96                 }
  97
  98                 #
  99                 # set the lists
 100                 #
 101                 $CTX->{OUTPUT}{SHARED_MODULES}{$key}{NAME} = $NAME;
 102                 @{$CTX->{OUTPUT}{SHARED_MODULES}{$key}{OBJ_LIST}} = @OBJ_LIST;
 103                 #
 104                 $CTX->{OUTPUT}{SHARED_MODULES}{$key}{MODULE} = $MODULE;
 105                 @{$CTX->{OUTPUT}{SHARED_MODULES}{$key}{DEPEND_LIST}} = @DEPEND_LIST;
 106                 @{$CTX->{OUTPUT}{SHARED_MODULES}{$key}{LINK_LIST}} = @LINK_LIST;
 107                 @{$CTX->{OUTPUT}{SHARED_MODULES}{$key}{LINK_FLAGS}} = @LINK_FLAGS;
 108         }
 109
 110         return;
 111 }
 112
 113 sub _generate_libraries($)
 114 {
 115         my $CTX = shift;
 116
 117         #
 118         # loop over all binaries
 119         #
 120         foreach my $key (sort keys %{$CTX->{DEPEND}{LIBRARIES}}) {
 121                 my $NAME = $CTX->{INPUT}{LIBRARIES}{$key}{NAME};
 122                 my @OBJ_LIST = @{$CTX->{INPUT}{LIBRARIES}{$key}{OBJ_FILES}};
 123                 my $MAJOR_VERSION = $CTX->{INPUT}{LIBRARIES}{$key}{MAJOR_VERSION};
 124                 my $MINOR_VERSION = $CTX->{INPUT}{LIBRARIES}{$key}{MINOR_VERSION};
 125                 my $RELEASE_VERSION = $CTX->{INPUT}{LIBRARIES}{$key}{RELEASE_VERSION};
 126                 #
 127                 my @DEPEND_LIST = ("\$(LIBRARY_$NAME\_OBJS)");
 128
 129                 my $STATIC_LIBRARY_NAME = $NAME.".a";
 130                 my @STATIC_LINK_LIST = ("\$(LIBRARY_$NAME\_OBJS)");
 131                 my @STATIC_LINK_FLAGS = ();
 132
 133                 my $SHARED_LIBRARY_NAME = $NAME.".so";
 134                 my $SHARED_LIBRARY_SONAME = $SHARED_LIBRARY_NAME.".$MAJOR_VERSION";
 135                 my $SHARED_LIBRARY_REALNAME = $SHARED_LIBRARY_SONAME.".$MINOR_VERSION.$RELEASE_VERSION";
 136                 my @SHARED_LINK_LIST = ("\$(LIBRARY_$NAME\_OBJS)");
 137                 my @SHARED_LINK_FLAGS = ("\@SONAMEFLAG\@$SHARED_LIBRARY_SONAME");
 138
 139                 push(@{$CTX->{OUTPUT}{PROTO}{OBJ_LIST}},"\$(LIBRARY_$key\_OBJS)");
 140
 141                 #
 142                 # not add to 'make all' for now
 143                 #
 144
 145                 foreach my $elem (@{$CTX->{DEPEND}{LIBRARIES}{$key}{SUBSYSTEMS_LIST}}) {
 146                         if (!defined($CTX->{DEPEND}{SUBSYSTEMS}{$elem})) {
 147                                 die("Library[$NAME] depends on unknown Subsystem[$elem]!\n");
 148                         }
 149                         push(@DEPEND_LIST,"\$(SUBSYSTEM_$elem\_OBJS)");
 150                         push(@STATIC_LINK_LIST,"\$(SUBSYSTEM_$elem\_OBJS)");
 151                         push(@SHARED_LINK_LIST,"\$(SUBSYSTEM_$elem\_OBJS)");
 152                 }
 153
 154                 foreach my $elem (@{$CTX->{DEPEND}{LIBRARIES}{$key}{LIBRARIES_LIST}}) {
 155                         if (!defined($CTX->{DEPEND}{EXT_LIBS}{$elem})) {
 156                                 die("Library[$NAME] depends on unknown External Library[$elem]!\n");
 157                         }
 158                         push(@SHARED_LINK_LIST,@{$CTX->{DEPEND}{EXT_LIBS}{$elem}{LIBS}});
 159                         push(@SHARED_LINK_FLAGS,@{$CTX->{DEPEND}{EXT_LIBS}{$elem}{LDFLAGS}});
 160                 }
 161
 162                 #
 163                 # set the lists
 164                 #
 165                 $CTX->{OUTPUT}{LIBRARIES}{$key}{NAME} = $NAME;
 166                 @{$CTX->{OUTPUT}{LIBRARIES}{$key}{OBJ_LIST}} = @OBJ_LIST;
 167                 #
 168                 @{$CTX->{OUTPUT}{LIBRARIES}{$key}{DEPEND_LIST}} = @DEPEND_LIST;
 169
 170                 $CTX->{OUTPUT}{LIBRARIES}{$key}{STATIC_LIBRARY_NAME} = $STATIC_LIBRARY_NAME;
 171                 @{$CTX->{OUTPUT}{LIBRARIES}{$key}{STATIC_LINK_LIST}} = @STATIC_LINK_LIST;
 172                 @{$CTX->{OUTPUT}{LIBRARIES}{$key}{STATIC_LINK_FLAGS}} = @STATIC_LINK_FLAGS;
 173
 174                 $CTX->{OUTPUT}{LIBRARIES}{$key}{SHARED_LIBRARY_NAME} = $SHARED_LIBRARY_NAME;
 175                 $CTX->{OUTPUT}{LIBRARIES}{$key}{SHARED_LIBRARY_REALNAME} = $SHARED_LIBRARY_REALNAME;
 176                 $CTX->{OUTPUT}{LIBRARIES}{$key}{SHARED_LIBRARY_SONAME} = $SHARED_LIBRARY_SONAME;
 177                 @{$CTX->{OUTPUT}{LIBRARIES}{$key}{SHARED_LINK_LIST}} = @SHARED_LINK_LIST;
 178                 @{$CTX->{OUTPUT}{LIBRARIES}{$key}{SHARED_LINK_FLAGS}} = @SHARED_LINK_FLAGS;
 179         }
 180
 181         return;
 182 }
 183
 184 sub _generate_binaries($)
 185 {
 186         my $CTX = shift;
 187
 188         #
 189         # loop over all binaries
 190         #
 191         foreach my $key (sort keys %{$CTX->{DEPEND}{BINARIES}}) {
 192                 my $NAME = $CTX->{INPUT}{BINARIES}{$key}{NAME};
 193                 my @OBJ_LIST = @{$CTX->{INPUT}{BINARIES}{$key}{OBJ_FILES}};
 194                 #
 195                 my $BINARY = $NAME;
 196                 my @DEPEND_LIST = ("\$(BINARY_$NAME\_OBJS)");
 197                 my @LINK_LIST = ("\$(BINARY_$NAME\_OBJS)");
 198                 my @LINK_FLAGS = ();
 199
 200                 push(@{$CTX->{OUTPUT}{PROTO}{OBJ_LIST}},"\$(BINARY_$key\_OBJS)");
 201                 push(@{$CTX->{OUTPUT}{TARGETS}{ALL}{DEPEND_LIST}},"bin/$BINARY");
 202
 203                 foreach my $elem (@{$CTX->{DEPEND}{BINARIES}{$key}{SUBSYSTEMS_LIST}}) {
 204                         if (!defined($CTX->{DEPEND}{SUBSYSTEMS}{$elem})) {
 205                                 die("Binary[$NAME] depends on unknown Subsystem[$elem]!\n");
 206                         }
 207                         push(@DEPEND_LIST,"\$(SUBSYSTEM_$elem\_OBJS)");
 208                         push(@LINK_LIST,"\$(SUBSYSTEM_$elem\_OBJS)");
 209                 }
 210
 211                 foreach my $elem (@{$CTX->{DEPEND}{BINARIES}{$key}{LIBRARIES_LIST}}) {
 212                         if (!defined($CTX->{DEPEND}{EXT_LIBS}{$elem})) {
 213                                 die("Binary[$NAME] depends on unknown External Library[$elem]!\n");
 214                         }
 215                         push(@LINK_LIST,@{$CTX->{DEPEND}{EXT_LIBS}{$elem}{LIBS}});
 216                         push(@LINK_FLAGS,@{$CTX->{DEPEND}{EXT_LIBS}{$elem}{LDFLAGS}});
 217                 }
 218
 219                 # Export all symbols...
 220                 push(@LINK_FLAGS,@{$CTX->{BUILD_ENV}{LD}{DYNEXP}});
 221
 222                 #
 223                 # set the lists
 224                 #
 225                 $CTX->{OUTPUT}{BINARIES}{$key}{NAME} = $NAME;
 226                 @{$CTX->{OUTPUT}{BINARIES}{$key}{OBJ_LIST}} = @OBJ_LIST;
 227                 #
 228                 $CTX->{OUTPUT}{BINARIES}{$key}{BINARY} = $BINARY;
 229                 @{$CTX->{OUTPUT}{BINARIES}{$key}{DEPEND_LIST}} = @DEPEND_LIST;
 230                 @{$CTX->{OUTPUT}{BINARIES}{$key}{LINK_LIST}} = @LINK_LIST;
 231                 @{$CTX->{OUTPUT}{BINARIES}{$key}{LINK_FLAGS}} = @LINK_FLAGS;
 232         }
 233
 234         return;
 235 }
 236
 237 ###########################################################
 238 # This function generates the output
 239 #
 240 # create_output($SMB_BUILD_CTX)
 241 #
 242 # $SMB_BUILD_CTX -      the global SMB_BUILD context
 243 sub create_output($)
 244 {
 245         my $CTX = shift;
 246
 247         $CTX->{OUTPUT}{PROTO} = ();
 248         @{$CTX->{OUTPUT}{PROTO}{OBJ_LIST}} = ();
 249
 250         $CTX->{OUTPUT}{TARGETS}{ALL} = ();
 251         $CTX->{OUTPUT}{TARGETS}{ALL}{TARGET} = "all";
 252         @{$CTX->{OUTPUT}{TARGETS}{ALL}{DEPEND_LIST}} = ();
 253
 254         _generate_ext_libs($CTX);
 255
 256         _generate_subsystems($CTX);
 257
 258         _generate_shared_modules($CTX);
 259
 260         _generate_libraries($CTX);
 261
 262         _generate_binaries($CTX);
 263
 264         return;
 265 }
 266
 267 1;