Changeset 5764:2305386b07ad in roaraudio


Ignore:
Timestamp:
11/21/12 15:57:16 (11 years ago)
Author:
phi
Branch:
default
Phase:
public
Message:

Added support to roar-config to check versions (Closes: #336)

Files:
3 edited

Legend:

Unmodified
Added
Removed
  • ChangeLog

    r5763 r5764  
    1212        * Added support for configureable memmgr backend (Closes: #334) 
    1313        * Moved notify debugging support out of roard into plugin debug-notify. 
     14        * Added support to roar-config to check versions (Closes: #336) 
    1415 
    1516v. 1.0beta7 - Tue Oct 23 2012 23:28 CEST 
  • doc/man1/roar-config.1

    r5748 r5764  
    1010 
    1111roar-config \-\-version 
     12 
     13roar-config \-\-compare-versions VERSIONA OPERATOR VERSIONB 
    1214 
    1315roar-config [{\-\-output-pc|\-\-output-normal}] [\-\-libs] [\-\-cflags] [LIB] 
     
    2527\fB--version\fR 
    2628Show version of library 
     29 
     30.TP 
     31\fB--compare-versions VERSIONA OPERATOR VERSIONB\fR 
     32Compares version VERSIONA against version VERSIONB using operator OPERATOR. 
     33Both versions must be in dotted format (e.g. 1.0.8) or the special keyword "current". 
     34This keyword represents the current used version. 
     35 
     36Operator may be "eq" (equal), "ne" (not equal), "gt" (greater than), "ge" (greater than or equal), 
     37"lt" (less than) or "le" (less than or equal). 
     38 
     39This function is mostly useful to check for minimum required or maximum supported versions of libroar 
     40in configure scripts. 
    2741 
    2842.TP 
  • roarclients/roar-config.c

    r5748 r5764  
    5353}, * flags_ptr = NULL; 
    5454 
     55struct version { 
     56 int major, minor, revision; 
     57}; 
     58 
     59static struct version parse_version(const char * version) { 
     60 struct version ret = {-1, -1, -1}; 
     61 char * next; 
     62 
     63 if ( !strcasecmp(version, "current") ) 
     64  version = COMMON_VERSION; 
     65 
     66 ret.major    = strtoll(version, &next, 0); 
     67 ret.minor    = strtoll(next+1, &next, 0); 
     68 ret.revision = strtoll(next+1, &next, 0); 
     69 
     70 return ret; 
     71} 
     72 
     73static int compare_versions_eq(struct version a, struct version b) { 
     74 return a.major == b.major && a.minor == b.minor && a.revision == b.revision; 
     75} 
     76 
     77static int compare_versions_gt(struct version a, struct version b) { 
     78 if ( a.major > b.major ) 
     79  return 1; 
     80 if ( a.minor > b.minor ) 
     81  return 1; 
     82 if ( a.revision > b.revision ) 
     83  return 1; 
     84 return 0; 
     85} 
     86 
     87static int compare_versions_ge(struct version a, struct version b) { 
     88 return compare_versions_gt(a, b) || compare_versions_eq(a, b); 
     89} 
     90 
     91static int compare_versions_lt(struct version a, struct version b) { 
     92 return compare_versions_gt(b, a); 
     93} 
     94 
     95static int compare_versions_le(struct version a, struct version b) { 
     96 return compare_versions_lt(a, b) || compare_versions_eq(a, b); 
     97} 
     98 
     99static const struct { 
     100 const char * op; 
     101 int neg; 
     102 int (*func)(struct version a, struct version b); 
     103} compare_versions_funcs[] = { 
     104 {"eq", 0, compare_versions_eq}, 
     105 {"ne", 1, compare_versions_eq}, 
     106 {"gt", 0, compare_versions_gt}, 
     107 {"ge", 0, compare_versions_ge}, 
     108 {"lt", 0, compare_versions_lt}, 
     109 {"le", 0, compare_versions_le} 
     110}; 
     111 
     112static int compare_versions(const char * a, const char * op, const char * b) { 
     113 struct version va = parse_version(a); 
     114 struct version vb = parse_version(b); 
     115 size_t i; 
     116 int ret; 
     117 
     118 ROAR_DBG("compare_versions(a='%s', op='%s', b='%s'): {%i, %i, %i} <%s> {%i, %i, %i}\n", a, op, b, va.major, va.minor, va.revision, op, vb.major, vb.minor, vb.revision); 
     119 
     120 for (i = 0; i < (sizeof(compare_versions_funcs)/sizeof(*compare_versions_funcs)); i++) { 
     121  if ( !strcasecmp(compare_versions_funcs[i].op, op) ) { 
     122   ret = compare_versions_funcs[i].func(va, vb); 
     123   if ( compare_versions_funcs[i].neg ) 
     124    ret = ret ? 0 : 1; 
     125 
     126   return ret ? 0 : 32; 
     127  } 
     128 } 
     129 
     130 ROAR_ERR("compare_versions(*): Operator \"%s\" not found.", op); 
     131 return 1; 
     132} 
     133 
    55134void print_path(const char * name, int null_as_universal, const char * product, const char * provider) { 
    56135 char * path = roar_libroar_get_path(name, null_as_universal, product, provider); 
     
    63142void usage (void) { 
    64143 printf("Usage: roar-config --version\n" 
     144        "       roar-config --compare-versions VERSIONA OPERATOR VERSIONB\n" 
    65145        "       roar-config [{--output-pc|--output-normal}] [--libs] [--cflags] [LIB]\n" 
    66146        "       roar-config [--product PRODUCT] [--provider PROVIDER] [--universal] --path PATH\n"); 
     
    70150 printf( 
    71151        "  --version           - Show version of library\n" 
     152        "  --compare-versions A OP B\n" 
     153        "                      - Compare version A against B with operator OP.\n" 
    72154        "  --path NAME         - Print path NAME\n" 
    73155        "  --product PRODUCT   - Product string for --path\n" 
     
    105187   usage(); 
    106188   return 0; 
     189  } else if ( !strcmp(argv[i], "--compare-versions") ) { 
     190   return compare_versions(argv[i+1], argv[i+2], argv[i+3]); 
    107191  } else if ( !strcmp(argv[i], "--product") ) { 
    108192   product = argv[++i]; 
Note: See TracChangeset for help on using the changeset viewer.