Commit: e4629b2485a9cec9cd023de36a68a2ed8591cc51 - mingw-get (git)

The MinGW.org Installation Manager Tool

Commit MetaInfo

• Révision: e4629b2485a9cec9cd023de36a68a2ed8591cc51 (tree)
• l'heure: 2012-02-21 06:08:05
• Auteur: Keith Marshall <keithmarshall@user...>
• Commiter: Keith Marshall

Message de Log

Propagate sysroot path settings to scripts via the environment.

Change Summary

• modified: ChangeLog
• modified: src/pkgbase.h
• modified: src/pkgexec.cpp
• modified: src/sysroot.cpp

Modification

--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,23 @@
[phone]  Keith Marshall  <[e-mail]>
+
+	Propagate sysroot path settings to scripts via the environment.
+
+	* src/pkgbase.h (PKG_PUTENV_FLAGS_MASK): New constant; it maps...
+	(PKG_PUTENV_DIRSEP_MSW, PKG_PUTENV_DIRSEP_POSIX): ...these flags...
+	(PKG_PUTENV_SCAN_VARNAME, PKG_PUTENV_NAME_TOUPPER): ...and these;
+	they are used to specify optional behavioural choices for...
+	(pkgPutEnv): ...this new function; declare it.
+
+	* src/sysroot.cpp (pkgPutEnv): Implement it.
+	(pkgXmlDocument::LoadSystemMap): Use it to add $SUBSYSTEM_SYSROOT path
+	specifications to the environment, for each named subsystem associated
+	with the active system map.
+
+	* src/pkgexec.cpp (pkgActionItem::Execute): Invoke pkgPutEnv() prior
+	to processing of each package install, upgrade, or remove action, so
+	as to update environment variable $SYSROOT to represent the sysroot
+	path for each package processed, during execution of script hooks.
+
 2012-02-17  Keith Marshall  <[e-mail]>
 
 	Implement hooks to support lua scripting interface.

--- a/src/pkgbase.h
+++ b/src/pkgbase.h
@@ -71,6 +71,19 @@
 # endif
 #endif
 
+/* Define an API for registering environment variables.
+ */
+EXTERN_C int pkgPutEnv( int, char* );
+
+#define PKG_PUTENV_DIRSEP_MSW 	 	(0x01)
+#define PKG_PUTENV_DIRSEP_POSIX 	(0x02)
+#define PKG_PUTENV_SCAN_VARNAME 	(0x04)
+#define PKG_PUTENV_NAME_TOUPPER  	(0x08)
+
+#define PKG_PUTENV_FLAGS_MASK		(0x0F)
+
+/* Begin class declarations.
+ */
 class pkgSpecs;
 
 class pkgXmlNode : public TiXmlElement

--- a/src/pkgexec.cpp
+++ b/src/pkgexec.cpp
@@ -4,7 +4,7 @@
  * $Id$
  *
  * Written by Keith Marshall <[e-mail]>
- * Copyright (C) 2009, 2010, 2011, MinGW Project
+ * Copyright (C) 2009, 2010, 2011, 2012, MinGW Project
  *
  *
  * Implementation of package management task scheduler and executive.
@@ -430,10 +430,36 @@ void pkgActionItem::Execute()
 	   * be performed, identifying the package to be processed.
 	   */
 	  const char *tarname;
-	  if( (tarname = current->Selection()->GetPropVal( tarname_key, NULL )) == NULL )
-	    tarname = current->Selection( to_remove )->GetPropVal( tarname_key, value_unknown );
+	  pkgXmlNode *ref = current->Selection();
+	  if( (tarname = ref->GetPropVal( tarname_key, NULL )) == NULL )
+	  {
+	    ref = current->Selection( to_remove );
+	    tarname = ref->GetPropVal( tarname_key, value_unknown );
+	  }
 	  dmh_printf( "%s: %s\n", action_name(current->flags & ACTION_MASK), tarname );
 
+	  /* Package pre/post processing scripts may need to
+	   * refer to the sysroot path for the package; place
+	   * a copy in the environment, to facilitate this.
+	   */
+	  pkgSpecs lookup( tarname );
+	  ref = ref->GetSysRoot( lookup.GetSubSystemName() );
+	  const char *path = ref->GetPropVal( pathname_key, NULL );
+	  if( path != NULL )
+	  {
+	    /* Format the sysroot path into an environment variable
+	     * assignment specification; note that the recorded path
+	     * name is likely to include macros such as "%R", so we
+	     * filter it through mkpath(), to expand them.
+	     */
+	    const char *nothing = "";
+	    char varspec_template[9 + strlen( path )];
+	    sprintf( varspec_template, "SYSROOT=%s", path );
+	    char varspec[mkpath( NULL, varspec_template, nothing, NULL )];
+	    mkpath( varspec, varspec_template, nothing, NULL );
+	    pkgPutEnv( PKG_PUTENV_DIRSEP_MSW, varspec );
+	  }
+
 	  /* Check for any outstanding requirement to invoke the
 	   * "self upgrade rites" process, so that we may install an
 	   * upgrade for mingw-get itself...

--- a/src/sysroot.cpp
+++ b/src/sysroot.cpp
@@ -113,7 +113,74 @@ static bool samepath( const char *tstpath, const char *refpath )
   return (*tstpath == *refpath);
 }
 
+EXTERN_C int pkgPutEnv( int flags, char *varspec )
+{
+  /* A helper routine for registration of sysroot path to
+   * subsystem name mappings in the process environment, so
+   * that they propagate to pre/post-processing hooks.
+   */
+  if( flags )
+  {
+    /* The flags allow us to specify certain transformations
+     * to be applied to the varspec.
+     */
+    char *ref = varspec;
+    flags |= PKG_PUTENV_SCAN_VARNAME;
+    do { if( (flags & PKG_PUTENV_NAME_TOUPPER) == PKG_PUTENV_NAME_TOUPPER )
+	 {
+	   /* The PKG_PUTENV_NAME_TOUPPER flag specifies that the varname
+	    * part of varspec may contain lower case characters, which are
+	    * to be converted to their upper case equivalents, before they
+	    * are stored in the environment...
+	    */
+	   if( *ref == '=' )
+	     /*
+	      * ...but such transformation does not apply to the value
+	      * part, so stop it when we find the first '=' character,
+	      * (which separates the name and value parts of varspec).
+	      */
+	     flags &= ~(PKG_PUTENV_SCAN_VARNAME | PKG_PUTENV_NAME_TOUPPER);
+
+	   else
+	     /* ...we haven't yet encountered the '=', so apply the
+	      * transformation.
+	      */
+	     *ref = toupper( *ref ); }
+
+	 else if( *ref == '=' )
+	   /*
+	    * We may be doing case transformation on the varname, so
+	    * note when we've passed the '=' which separates it from
+	    * any assigned value.
+	    */
+	   flags &= ~PKG_PUTENV_SCAN_VARNAME;
+
+	 /* Once we've reached the value part of varspec, flags which
+	  * include the PKG_PUTENV_DIRSEP_MSW bit, but do not include
+	  * the PKG_PUTENV_DIRSEP_POSIX bit, request that POSIX style
+	  * directory separators are to be replaced by the MS-Windows
+	  * '\' counterpart...
+	  */
+	 if( ((flags & PKG_PUTENV_FLAGS_MASK) == PKG_PUTENV_DIRSEP_MSW) &&
+	     (*ref == '/')   ) *ref = '\\';
+
+	 /* ...while conversely, the PKG_PUTENV_DIRSEP_POSIX bit,
+	  * (without PKG_PUTENV_DIRSEP_MSW), requests MS-Windows to
+	  * POSIX style transformation.
+	  */
+	 else if( ((flags & PKG_PUTENV_FLAGS_MASK) == PKG_PUTENV_DIRSEP_POSIX)
+	     &&   (*ref == '\\')   ) *ref = '/';
+
+       } while( *++ref ); }
+
+  /* Finally, we insert the variable specification, (which may have
+   * been transformed above), into the process environment.
+   */
+  return putenv( varspec );
+}
+
 void pkgXmlDocument::LoadSystemMap()
+#define PKG_SYSROOT_OPTIONS (PKG_PUTENV_NAME_TOUPPER | PKG_PUTENV_DIRSEP_MSW)
 {
   /* Load an initial, or a replacement, system map into the
    * internal XML database image space.
@@ -188,11 +255,31 @@ void pkgXmlDocument::LoadSystemMap()
 	    && ! samepath( path, sysroot->GetPropVal( pathname_key, NULL )) )
 	      sysroot = sysroot->FindNextAssociate( sysroot_key );
 
- 	    DEBUG_INVOKE_IF( DEBUG_REQUEST( DEBUG_TRACE_INIT ),
+	    /* Identify the subsystem name, logging a trace notification
+	     * when running with appropriate debugging traces enabled.
+	     */
+	    const char *sysname = subsystem->GetPropVal( subsystem_key, NULL );
+	    DEBUG_INVOKE_IF( DEBUG_REQUEST( DEBUG_TRACE_INIT ),
 		dmh_printf( "Bind subsystem %s: sysroot = %s\n",
-		  subsystem->GetPropVal( subsystem_key, "<unknown>" ), path
+		  (sysname == NULL) ? value_unknown : sysname,
+		  path
 	      ));
 
+	    if( sysname != NULL )
+	    {
+	      /* Register the associated sysroot in the process environment,
+	       * so that it may become available to pre/post-processing hooks;
+	       * note that the recorded path name is likely to include macros
+	       * such as "%R", so we filter it through mkpath() to ensure
+	       * that they are expanded.
+	       */
+	      char varname_template[11 + strlen( path )];
+	      sprintf( varname_template, "%%F_SYSROOT=%s", path );
+	      char varname[mkpath( NULL, varname_template, sysname, NULL )];
+	      mkpath( varname, varname_template, sysname, NULL );
+	      pkgPutEnv( PKG_SYSROOT_OPTIONS, varname );
+	    }
+
 	    if( sysroot == NULL )
 	    {
 	      /* This sysroot has not yet been registered...
@@ -309,10 +396,23 @@ void pkgXmlDocument::LoadSystemMap()
     /* Finally, if the current system map was not loaded...
      */
     if( to_clear != NULL )
-      /*
-       * ...then we delete its declaration from the active data space.
+    {
+      /* ...clean up its declaration data...
+       */
+      const char *sysname = to_clear->GetPropVal( subsystem_key, NULL );
+      if( sysname != NULL )
+      {
+	/* ...deleting its sysroot registration entry, if any,
+	 * from the process environment...
+	 */
+  	char varname[9 + strlen( sysname )];
+  	sprintf( varname, "%s_SYSROOT", sysname );
+  	pkgPutEnv( PKG_PUTENV_NAME_TOUPPER, varname );
+      }
+      /* ...and removing its reference from the active XML data space.
        */
       dbase->DeleteChild( to_clear );
+    }
   }
 }