semver.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	semver_version_s

Macros
#define	SEMVER_VERSION   "0.2.0"

Typedefs
typedef struct semver_version_s	semver_t

Functions
int	semver_satisfies (semver_t x, semver_t y, const char *op)
int	semver_satisfies_caret (semver_t x, semver_t y)
int	semver_satisfies_patch (semver_t x, semver_t y)
int	semver_compare (semver_t x, semver_t y)
int	semver_compare_version (semver_t x, semver_t y)
int	semver_compare_prerelease (semver_t x, semver_t y)
int	semver_gt (semver_t x, semver_t y)
int	semver_gte (semver_t x, semver_t y)
int	semver_lt (semver_t x, semver_t y)
int	semver_lte (semver_t x, semver_t y)
int	semver_eq (semver_t x, semver_t y)
int	semver_neq (semver_t x, semver_t y)
int	semver_parse (const char *str, semver_t *ver)
int	semver_parse_version (const char *str, semver_t *ver)
void	semver_render (semver_t *x, char *dest)
int	semver_numeric (semver_t *x)
void	semver_bump (semver_t *x)
void	semver_bump_minor (semver_t *x)
void	semver_bump_patch (semver_t *x)
void	semver_free (semver_t *x)
int	semver_is_valid (const char *s)
int	semver_clean (char *s)
char *	semver_strdup (const char *src)
semver_t	semver_copy (const semver_t *ver)

---

Class Documentation

semver_version_s

struct semver_version_s

semver_t struct

Class Members
int	major
char *	metadata
int	minor
int	patch
char *	prerelease

Macro Definition Documentation

SEMVER_VERSION

#define SEMVER_VERSION   "0.2.0"

Typedef Documentation

semver_t

typedef struct semver_version_s semver_t

semver_t struct

Function Documentation

semver_bump()

void semver_bump

(

semver_t *

x

)

Version bump helpers

                          {
  x->major++;
}

semver_bump_minor()

void semver_bump_minor

(

semver_t *

x

)

                                {
  x->minor++;
}

semver_bump_patch()

void semver_bump_patch

(

semver_t *

x

)

                                {
  x->patch++;
}

semver_clean()

int semver_clean

(

char *

s

)

Removes non-valid characters in the given string.

Returns:

0 - Valid -1 - Invalid input

                       {
  size_t i, len, mlen;
  int res;
  if (has_valid_length(s) == 0) return -1;
 
  len = strlen(s);
  mlen = strlen(VALID_CHARS);
 
  for (i = 0; i < len; i++) {
    if (contains(s[i], VALID_CHARS, mlen) == 0) {
      res = strcut(s, (int)i, 1);
      if(res == -1) return -1;
      --len; --i;
    }
  }
 
  return 0;
}

References contains(), has_valid_length(), strcut(), and VALID_CHARS.

Here is the call graph for this function:

semver_compare()

int semver_compare	(	semver_t	x,
		semver_t	y
	)

Compare two semantic versions (x, y).

Returns:

• 1 if x is higher than y
• 0 if x is equal to y
• -1 if x is lower than y

                                        {
  int res;
 
  if ((res = semver_compare_version(x, y)) == 0) {
    return semver_compare_prerelease(x, y);
  }
 
  return res;
}

References semver_compare_prerelease(), and semver_compare_version().

Referenced by semver_eq(), semver_gt(), semver_gte(), semver_lt(), semver_lte(), and semver_neq().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_compare_prerelease()

int semver_compare_prerelease	(	semver_t	x,
		semver_t	y
	)

                                                   {
  return compare_prerelease(x.prerelease, y.prerelease);
}

References compare_prerelease().

Referenced by semver_compare().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_compare_version()

int semver_compare_version	(	semver_t	x,
		semver_t	y
	)

Performs a major, minor and patch binary comparison (x, y). This function is mostly used internally

Returns:

0 - If versiona are equal 1 - If x is higher than y -1 - If x is lower than y

                                                {
  int res;
 
  if ((res = binary_comparison(x.major, y.major)) == 0) {
    if ((res = binary_comparison(x.minor, y.minor)) == 0) {
      return binary_comparison(x.patch, y.patch);
    }
  }
 
  return res;
}

References binary_comparison().

Referenced by semver_compare().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_copy()

semver_t semver_copy

(

const semver_t *

ver

)

                                 {
  semver_t res = *ver;
  if (ver->metadata != NULL) {
    res.metadata = strdup(ver->metadata);
  }
  if (ver->prerelease != NULL) {
    res.prerelease = strdup(ver->prerelease);
  }
  return res;
}

References semver_version_s::metadata, and semver_version_s::prerelease.

Referenced by Slic3r::Semver::operator=().

Here is the caller graph for this function:

semver_eq()

int semver_eq	(	semver_t	x,
		semver_t	y
	)

Performs a equality comparison

                                   {
  return semver_compare(x, y) == 0;
}

References semver_compare().

Referenced by semver_satisfies().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_free()

void semver_free

(

semver_t *

x

)

Free heep allocated memory of a given semver. This is just a convenient function that you should call when you're done.

                          {
  if (x->metadata) {
    free(x->metadata);
    x->metadata = NULL;
  }
  if (x->prerelease) {
    free(x->prerelease);
    x->prerelease = NULL;
  }
}

References free().

Referenced by Slic3r::Semver::~Semver(), Slic3r::Semver::operator=(), and Slic3r::Semver::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_gt()

int semver_gt	(	semver_t	x,
		semver_t	y
	)

Performs a greater than comparison

                                   {
  return semver_compare(x, y) == 1;
}

References semver_compare().

Referenced by semver_satisfies().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_gte()

int semver_gte	(	semver_t	x,
		semver_t	y
	)

Performs a greater than or equal comparison

                                    {
  return semver_compare(x, y) >= 0;
}

References semver_compare().

Referenced by semver_satisfies().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_is_valid()

int semver_is_valid

(

const char *

s

)

Checks if a given semver string is valid

Returns:

1 - Valid expression 0 - Invalid

                                {
  return has_valid_length(s)
      && has_valid_chars(s, VALID_CHARS);
}

References has_valid_chars(), has_valid_length(), and VALID_CHARS.

Referenced by semver_parse().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_lt()

int semver_lt	(	semver_t	x,
		semver_t	y
	)

Performs a lower than comparison

                                   {
  return semver_compare(x, y) == -1;
}

References semver_compare().

Referenced by semver_satisfies().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_lte()

int semver_lte	(	semver_t	x,
		semver_t	y
	)

Performs a lower than or equal comparison

                                    {
  return semver_compare(x, y) <= 0;
}

References semver_compare().

Referenced by semver_satisfies().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_neq()

int semver_neq	(	semver_t	x,
		semver_t	y
	)

Performs a non equal to comparison

                                    {
  return semver_compare(x, y) != 0;
}

References semver_compare().

Here is the call graph for this function:

semver_numeric()

int semver_numeric

(

semver_t *

x

)

Render a given semver as numeric value. Useful for ordering and filtering.

                             {
  int num;
  char buf[SLICE_SIZE * 3];
  memset(&buf, 0, SLICE_SIZE * 3);
 
  if (x->major) concat_num(buf, x->major, NULL);
  if (x->minor) concat_num(buf, x->minor, NULL);
  if (x->patch) concat_num(buf, x->patch, NULL);
 
  num = parse_int(buf);
  if(num == -1) return -1;
 
  if (x->prerelease) num += char_to_int(x->prerelease);
  if (x->metadata) num += char_to_int(x->metadata);
 
  return num;
}

References char_to_int(), concat_num(), parse_int(), and SLICE_SIZE.

Here is the call graph for this function:

semver_parse()

int semver_parse	(	const char *	str,
		semver_t *	ver
	)

Parses a string as semver expression.

Returns:

0 - Parsed successfully -1 - In case of error

                                              {
  int valid, res;
  size_t len;
  char *buf;
  valid = semver_is_valid(str);
  if (!valid) return -1;
 
  len = strlen(str);
  buf = calloc(len + 1, sizeof(*buf));
  if (buf == NULL) return -1;
  strcpy(buf, str);
 
  ver->metadata = parse_slice(buf, MT_DELIMITER[0]);
  ver->prerelease = parse_slice(buf, PR_DELIMITER[0]);
 
  res = semver_parse_version(buf, ver);
  free(buf);
#if DEBUG > 0
  printf("[debug] semver.c %s = %d.%d.%d, %s %s\n", str, ver->major, ver->minor, ver->patch, ver->prerelease, ver->metadata);
#endif
  return res;
}

References free(), semver_version_s::major, semver_version_s::metadata, semver_version_s::minor, MT_DELIMITER, parse_slice(), semver_version_s::patch, PR_DELIMITER, semver_version_s::prerelease, semver_is_valid(), and semver_parse_version().

Referenced by Slic3r::Semver::parse().

Here is the call graph for this function:

Here is the caller graph for this function:

semver_parse_version()

int semver_parse_version	(	const char *	str,
		semver_t *	ver
	)

Parses a given string as semver expression.

Returns:

0 - Parsed successfully -1 - Parse error or invalid

                                                      {
  size_t len;
  int index, value;
  char *slice, *next, *endptr;
  slice = (char *) str;
  index = 0;
 
  // non mandatory
  ver->patch = 0;
 
  while (slice != NULL && index++ < 4) {
    next = strchr(slice, DELIMITER[0]);
    if (next == NULL)
      len = strlen(slice);
    else
      len = next - slice;
    if (len > SLICE_SIZE) return -1;
 
    /* Cast to integer and store */
    value = strtol(slice, &endptr, 10);
    if (endptr != next && *endptr != '\0') return -1;
 
    switch (index) {
      case 1: ver->major = value; break;
      case 2: ver->minor = value; break;
      case 3: ver->patch = value; break;
    }
 
    /* Continue with the next slice */
    if (next == NULL)
      slice = NULL;
    else
      slice = next + 1;
  }
 
  // Major and minor versions are mandatory, patch version is not mandatory.
  return (index == 2 || index == 3) ? 0 : -1;
}

References DELIMITER, semver_version_s::major, semver_version_s::minor, semver_version_s::patch, and SLICE_SIZE.

Referenced by semver_parse().

Here is the caller graph for this function:

semver_render()

void semver_render	(	semver_t *	x,
		char *	dest
	)

Render a given semver as string

                                        {
  if (x->major) concat_num(dest, x->major, NULL);
  if (x->minor) concat_num(dest, x->minor, DELIMITER);
  if (x->patch) concat_num(dest, x->patch, DELIMITER);
  if (x->prerelease) concat_char(dest, x->prerelease, PR_DELIMITER);
  if (x->metadata) concat_char(dest, x->metadata, MT_DELIMITER);
}

References concat_char(), concat_num(), DELIMITER, MT_DELIMITER, and PR_DELIMITER.

Here is the call graph for this function:

semver_satisfies()

int semver_satisfies	(	semver_t	x,
		semver_t	y,
		const char *	op
	)

Set prototypes

Checks if both versions can be satisfied based on the given comparison operator.

Allowed operators:

• = - Equality
• >= - Higher or equal to
• <= - Lower or equal to
• < - Lower than
• > - Higher than
• ^ - Caret comparison (see https://docs.npmjs.com/misc/semver#caret-ranges-1-2-3-0-2-5-0-0-4)
• ~ - Tilde comparison (see https://docs.npmjs.com/misc/semver#tilde-ranges-1-2-3-1-2-1)

Returns:

1 - Can be satisfied 0 - Cannot be satisfied

                                                          {
  int first, second;
  /* Extract the comparison operator */
  first = op[0];
  second = op[1];
 
  /* Caret operator */
  if (first == SYMBOL_CF)
    return semver_satisfies_caret(x, y);
 
  /* Tilde operator */
  if (first == SYMBOL_TF)
    return semver_satisfies_patch(x, y);
 
  /* Strict equality */
  if (first == SYMBOL_EQ)
    return semver_eq(x, y);
 
  /* Greater than or equal comparison */
  if (first == SYMBOL_GT) {
    if (second == SYMBOL_EQ) {
      return semver_gte(x, y);
    }
    return semver_gt(x, y);
  }
 
  /* Lower than or equal comparison */
  if (first == SYMBOL_LT) {
    if (second == SYMBOL_EQ) {
      return semver_lte(x, y);
    }
    return semver_lt(x, y);
  }
 
  return 0;
}

References semver_eq(), semver_gt(), semver_gte(), semver_lt(), semver_lte(), semver_satisfies_caret(), semver_satisfies_patch(), SYMBOL_CF, SYMBOL_EQ, SYMBOL_GT, SYMBOL_LT, and SYMBOL_TF.

Here is the call graph for this function:

semver_satisfies_caret()

int semver_satisfies_caret	(	semver_t	x,
		semver_t	y
	)

Checks if version x can be satisfied by y performing a comparison with caret operator.

See: https://docs.npmjs.com/misc/semver#caret-ranges-1-2-3-0-2-5-0-0-4

Returns:

1 - Can be satisfied 0 - Cannot be satisfied

                                                {
  if (x.major == y.major) {
    if (x.major == 0) {
      return x.minor >= y.minor;
    }
    return 1;
  }
  return 0;
}

Referenced by semver_satisfies().

Here is the caller graph for this function:

semver_satisfies_patch()

int semver_satisfies_patch	(	semver_t	x,
		semver_t	y
	)

Checks if version x can be satisfied by y performing a comparison with tilde operator.

See: https://docs.npmjs.com/misc/semver#tilde-ranges-1-2-3-1-2-1

Returns:

1 - Can be satisfied 0 - Cannot be satisfied

                                                {
  return x.major == y.major
      && x.minor == y.minor;
}

Referenced by semver_satisfies().

Here is the caller graph for this function:

semver_strdup()

char * semver_strdup

(

const char *

src

)

                                     {
  if (src == NULL) return NULL;
  size_t len = strlen(src) + 1;
  char *res = malloc(len);
  return res != NULL ? (char *) memcpy(res, src, len) : NULL;
}

References malloc().

Here is the call graph for this function: