Commit: e15828a255b9c4ad23b572ba115f125c6ab797f5 - mingw-get (git)

The MinGW.org Installation Manager Tool

Commit MetaInfo

• Révision: e15828a255b9c4ad23b572ba115f125c6ab797f5 (tree)
• l'heure: 2011-10-05 06:07:32
• Auteur: Keith Marshall <keithmarshall@user...>
• Commiter: Keith Marshall

Message de Log

Establish mapping from release tarname to source tarname.

Change Summary

• modified: ChangeLog
• modified: src/pkgname.cpp
• modified: src/pkgreqs.cpp

Modification

--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
[phone]  Keith Marshall  <[e-mail]>
+
+	Establish mapping from release tarname to source tarname.
+
+	* src/pkgreqs.cpp (inherited_requirement): New inline function.
+	(requirement): Use it; adapt to propagate release archive format and
+	compression type fields, in addition to version fields, when resolving
+	"%" wildcard matches within the template for the resultant tarname.
+	(pkgAssociateName): New public function; implement it for use by...
+	* src/pkgname.cpp (pkgResolvedName): ...this new inline function.
+	(pkgXmlNode::SourceArchiveName): Use it; adapt to accept a category
+	selector, so it may resolve source or licence tarnames on demand.
+
 2011-10-02  Keith Marshall  <[e-mail]>
 
 	Facilitate downloads using diverse cache directories.

--- a/src/pkgname.cpp
+++ b/src/pkgname.cpp
@@ -4,7 +4,7 @@
  * $Id$
  *
  * Written by Keith Marshall <[e-mail]>
- * Copyright (C) 2009, 2010, MinGW Project
+ * Copyright (C) 2009, 2010, 2011, MinGW Project
  *
  *
  * Implementation for the non-inherited components of the pkgXmlNode
@@ -33,6 +33,8 @@
 #include "dmh.h"
 #include "pkgbase.h"
 #include "pkgkeys.h"
+#include "pkginfo.h"
+#include "pkgtask.h"
 
 static
 const char *pkgArchiveName( pkgXmlNode *rel, const char *tag, unsigned opt )
@@ -133,7 +135,147 @@ const char *pkgArchiveName( pkgXmlNode *rel, const char *tag, unsigned opt )
   return (opt || matched) ? rel->GetPropVal( tarname_key, NULL ) : NULL;
 }
 
-const char *pkgXmlNode::SourceArchiveName()
+EXTERN_C const char *pkgAssociateName( const char *, const char * );
+
+static inline
+const char *pkgResolvedName( pkgXmlNode *rel, const char *tag, const char *ext )
+{
+  /* Local helper function to resolve the mapping from a released
+   * package name, as identified from the XML release element "rel",
+   * to its corresponding source or licence package name, according
+   * to the selection of "source" or "licence" specified by "tag",
+   * with "ext" passed a "src" or "lic" respectively.
+   */
+  const char *refname;
+  const char *retname = NULL;
+
+  /* First, we retrieve the released package name...
+   */
+  if( (refname = pkgArchiveName( rel, release_key, 1 )) != NULL )
+  {
+    /* ...and if successful, look for an explicit reference to
+     * the source or licence package, embedded within the release
+     * specification itself.
+     */
+    if( (retname = pkgArchiveName( rel, tag, 0 )) == NULL )
+    {
+      /* When this fails to identify the required mapping,
+       * then we look for a generic reference, defined for
+       * the containing package.
+       */
+      pkgXmlNode *enc = rel->GetParent();
+
+      /* A generic reference may be placed at any nesting
+       * level, between the enclosing package element and
+       * the release to which it relates; thus, starting
+       * at the first enclosing level...
+       */
+      rel = NULL;
+      while( enc != NULL )
+      {
+	/* ...enumerate reference specifications of the
+	 * appropriate type, examining all children of
+	 * the enclosing element.
+	 */
+	unsigned matched = 0;
+	pkgXmlNode *child = enc->GetChildren();
+	while( child != NULL )
+	{
+	  /* We have a child, which we have not examined...
+	   */
+	  if( child->IsElementOfType( tag ) )
+	  {
+	    /* ...and it is of the required "tag" type.
+	     */
+	    if( matched++ )
+	      /*
+	       * We already had a candidate match, so we
+	       * diagnose but otherwise this duplicate...
+	       */
+	      dmh_notify( DMH_WARNING,
+		  "redundant %s specification ignored\n", tag
+		);
+
+	    else
+	      /* This is the first candidate match found,
+	       * so we accept it.
+	       */
+	      rel = child;
+	  }
+	  /* Continue examining child elements, until no more
+	   * are present at the current nesting level.
+	   */
+	  child = child->GetNext();
+	}
+
+	/* When we've completed the examination of all children
+	 * at a given nesting level, without finding a matching
+	 * specification, and that level is still within the
+	 * enclosing package element...
+	 */
+	if( (rel == NULL) && ! enc->IsElementOfType( package_key ) )
+	  /*
+	   * ...then we extend the search to the next enclosing
+	   * level of nesting...
+	   */
+	  enc = enc->GetParent();
+
+	else
+	  /* ...otherwise, we abandon the search.
+	   */
+	  enc = NULL;
+      }
+
+      /* If we've searched all available nesting levels,
+       * and failed to locate the requisite specification...
+       */
+      if( rel == NULL )
+      {
+	/* ...then we assume that the requisite tarname
+	 * is identical to the release tarname, with the
+	 * appropriate "ext" substitution for the package
+	 * class identification...
+	 */
+	pkgSpecs resolved( refname );
+	resolved.SetComponentClass( ext );
+	/*
+	 * ...so, having made the substitution,
+	 * we return the resultant tarname, noting
+	 * that this automatically allocates space
+	 * on the heap, for the returned string.
+	 */
+	return resolved.GetTarName();
+      }
+      else
+	/* We did find a mappingspecification, so we
+	 * extract a tarname template from it.
+	 */
+	retname = rel->GetPropVal( tarname_key, NULL );
+    }
+    else if( strcmp( retname, value_none ) == 0 )
+      /*
+       * The package is virtual, or an explicit mapping
+       * specification indicates that there is no related
+       * source or licence package; return NULL to advise
+       * the caller of this.
+       */
+      return NULL;
+
+    /* If we get to here, we found a mapping specification;
+     * it may be a template, so resolve any substitutions which
+     * it must inherit from the released package tarname, again
+     * noting that this allocates heap memory for the result.
+     */
+    retname = pkgAssociateName( retname, refname );
+  }
+
+  /* Finally, how ever we resolved the mapping, we return
+   * the result.
+   */
+  return retname;
+}
+
+const char *pkgXmlNode::SourceArchiveName( unsigned long category )
 {
   /* Applicable only for XML nodes designated as "release".
    *
@@ -146,7 +288,22 @@ const char *pkgXmlNode::SourceArchiveName()
    * not represent a "release", or if it does not have a contained
    * "source" element specifying a "tarname" property.
    */
-  return pkgArchiveName( this, source_key, 0 );
+  const char *tag = "lic";
+  if( category != ACTION_LICENCE )
+  {
+    /* We may have been asked to explicitly override the "source"
+     * mapping, returning the "licence" reference instead; where
+     * this special exception is NOT requested, then we enforce
+     * the default case.
+     */
+    category = ACTION_SOURCE;
+    tag = "src";
+  }
+
+  /* In either case, pkgResolvedName() determines the appropriate
+   * archive name, which it automatically returns on the heap.
+   */
+  return pkgResolvedName( this, action_name( category ), tag );
 }
 
 const char *pkgXmlNode::ArchiveName()

--- a/src/pkgreqs.cpp
+++ b/src/pkgreqs.cpp
@@ -327,6 +327,16 @@ enum inherit_mode
   INHERIT_ALL		/* "%" matches the entire version string      */
 };
 
+static inline
+bool inherited_requirement( const char *field )
+{
+  /* Local helper function to identify a template field which is
+   * specified exactly as "%", and therefore must inherit its value
+   * from the referring package specification.
+   */
+  return ((field != NULL) && (field[0] == '%') && (field[1] == '\0'));
+}
+
 static
 enum inherit_mode inherited( const char *ver, const char *bld )
 {
@@ -341,7 +351,7 @@ enum inherit_mode inherited( const char *ver, const char *bld )
   /* Noting that the "%" wildcard must represent the respective part
    * of the version specification in its entirety...
    */
-  if( (ver != NULL) && (ver[0] == '%') && (ver[1] == '\0') )
+  if( inherited_requirement( ver ) )
     /*
      * ...flag a match on the "major.minor.patch" specification.
      */
@@ -434,6 +444,18 @@ const char *requirement( const char *wanted, pkgSpecs *dep )
      */
     id.SetSubSystemBuild( dep->GetSubSystemBuild() );
 
+  /* To establish association between source and binary package names,
+   * we may also need to propagate archive and compression type fields...
+   */
+  if( inherited_requirement( id.GetPackageFormat()) )
+  {
+    id.SetPackageFormat( dep->GetPackageFormat() );
+    if( id.GetCompressionType() == NULL )
+      id.SetCompressionType( dep->GetCompressionType() );
+  }
+  else if( inherited_requirement( id.GetCompressionType()) )
+    id.SetCompressionType( dep->GetCompressionType() );
+
   /* Finally, reconstitute the canonical tarname representation of the
    * specification, from its decomposed representation; (as a side effect,
    * this automatically places the return string on the heap).
@@ -507,4 +529,14 @@ const char * pkgActionItem::SetRequirements( pkgXmlNode *req, pkgSpecs *dep )
   return (min_wanted == NULL) ? max_wanted : min_wanted;
 }
 
+EXTERN_C const char *pkgAssociateName( const char *map, const char *from )
+{
+  /* Public function for derivation of the name of an associate package,
+   * such as a source package, from the name of the primary package, based
+   * on the relationship specified by the template passed via "map".
+   */
+  pkgSpecs ref( from );
+  return requirement( map, &ref );
+}
+
 /* $RCSfile$: end of file */