semver.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "semver.h"

Include dependency graph for semver.c:

Go to the source code of this file.

Macros
#define	SLICE_SIZE   50
#define	DELIMITER   "."
#define	PR_DELIMITER   "-"
#define	MT_DELIMITER   "+"
#define	NUMBERS   "0123456789"
#define	ALPHA   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define	DELIMITERS   DELIMITER PR_DELIMITER MT_DELIMITER
#define	VALID_CHARS   NUMBERS ALPHA DELIMITERS

Enumerations
enum	operators {   SYMBOL_GT = 0x3e , SYMBOL_LT = 0x3c , SYMBOL_EQ = 0x3d , SYMBOL_TF = 0x7e ,   SYMBOL_CF = 0x5e }

Functions
static int	strcut (char *str, int begin, int len)
static int	contains (const char c, const char *matrix, size_t len)
static int	has_valid_chars (const char *str, const char *matrix)
static int	binary_comparison (int x, int y)
static int	parse_int (const char *s)
static char *	parse_slice (char *buf, char sep)
int	semver_parse (const char *str, semver_t *ver)
int	semver_parse_version (const char *str, semver_t *ver)
static int	compare_prerelease (char *x, char *y)
int	semver_compare_prerelease (semver_t x, semver_t y)
int	semver_compare_version (semver_t x, semver_t y)
int	semver_compare (semver_t x, semver_t y)
int	semver_gt (semver_t x, semver_t y)
int	semver_lt (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_gte (semver_t x, semver_t y)
int	semver_lte (semver_t x, semver_t y)
int	semver_satisfies_caret (semver_t x, semver_t y)
int	semver_satisfies_patch (semver_t x, semver_t y)
int	semver_satisfies (semver_t x, semver_t y, const char *op)
void	semver_free (semver_t *x)
static void	concat_num (char *str, int x, char *sep)
static void	concat_char (char *str, char *x, char *sep)
void	semver_render (semver_t *x, char *dest)
void	semver_bump (semver_t *x)
void	semver_bump_minor (semver_t *x)
void	semver_bump_patch (semver_t *x)
static int	has_valid_length (const char *s)
int	semver_is_valid (const char *s)
int	semver_clean (char *s)
static int	char_to_int (const char *str)
int	semver_numeric (semver_t *x)
char *	semver_strdup (const char *src)
semver_t	semver_copy (const semver_t *ver)

Variables
static const size_t	MAX_SIZE = sizeof(char) * 255
static const int	MAX_SAFE_INT = (unsigned int) -1 >> 1

Macro Definition Documentation

ALPHA

#define ALPHA   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

DELIMITER

#define DELIMITER   "."

DELIMITERS

#define DELIMITERS   DELIMITER PR_DELIMITER MT_DELIMITER

MT_DELIMITER

#define MT_DELIMITER   "+"

NUMBERS

#define NUMBERS   "0123456789"

PR_DELIMITER

#define PR_DELIMITER   "-"

SLICE_SIZE

#define SLICE_SIZE   50

VALID_CHARS

#define VALID_CHARS   NUMBERS ALPHA DELIMITERS

Enumeration Type Documentation

operators

enum operators

Define comparison operators, storing the ASCII code per each symbol in hexadecimal notation.

Enumerator
SYMBOL_GT
SYMBOL_LT
SYMBOL_EQ
SYMBOL_TF
SYMBOL_CF

               {
  SYMBOL_GT = 0x3e,
  SYMBOL_LT = 0x3c,
  SYMBOL_EQ = 0x3d,
  SYMBOL_TF = 0x7e,
  SYMBOL_CF = 0x5e
};

Function Documentation

binary_comparison()

static int binary_comparison ( int  x, int  y  )

static

                                 {
  if (x == y) return 0;
  if (x > y) return 1;
  return -1;
}

Referenced by semver_compare_version().

Here is the caller graph for this function:

char_to_int()

static int char_to_int ( const char *  str )

static

                               {
  int buf;
  size_t i,len, mlen;
  buf = 0;
  len = strlen(str);
  mlen = strlen(VALID_CHARS);
 
  for (i = 0; i < len; i++)
    if (contains(str[i], VALID_CHARS, mlen))
      buf += (int) str[i];
 
  return buf;
}

References contains(), and VALID_CHARS.

Referenced by semver_numeric().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_prerelease()

static int compare_prerelease ( char *  x, char *  y  )

static

                                      {
  char *lastx, *lasty, *xptr, *yptr, *endptr;
  size_t xlen, ylen, xn, yn, min;
  int xisnum, yisnum, xnum, ynum;
  int res;
  if (x == NULL && y == NULL) return 0;
  if (y == NULL && x) return -1;
  if (x == NULL && y) return 1;
 
  lastx = x;
  lasty = y;
  xlen = strlen(x);
  ylen = strlen(y);
 
  while (1) {
    if ((xptr = strchr(lastx, DELIMITER[0])) == NULL)
      xptr = x + xlen;
    if ((yptr = strchr(lasty, DELIMITER[0])) == NULL)
      yptr = y + ylen;
 
    xnum = strtol(lastx, &endptr, 10);
    xisnum = endptr == xptr ? 1 : 0;
    ynum = strtol(lasty, &endptr, 10);
    yisnum = endptr == yptr ? 1 : 0;
 
    if (xisnum && !yisnum) return -1;
    if (!xisnum && yisnum) return 1;
 
    if (xisnum && yisnum) {
      /* Numerical comparison */
      if (xnum != ynum) return xnum < ynum ? -1 : 1;
    } else {
      /* String comparison */
      xn = xptr - lastx;
      yn = yptr - lasty;
      min = xn < yn ? xn : yn;
      if ((res = strncmp(lastx, lasty, min))) return res < 0 ? -1 : 1;
      if (xn != yn) return xn < yn ? -1 : 1;
    }
 
    lastx = xptr + 1;
    lasty = yptr + 1;
    if (lastx == x + xlen + 1 && lasty == y + ylen + 1) break;
    if (lastx == x + xlen + 1) return -1;
    if (lasty == y + ylen + 1) return 1;
  }
 
  return 0;
}

References DELIMITER.

Referenced by semver_compare_prerelease().

Here is the caller graph for this function:

concat_char()

static void concat_char ( char *  str, char *  x, char *  sep  )

static

                                               {
  char buf[SLICE_SIZE] = {0};
  sprintf(buf, "%s%s", sep, x);
  strcat(str, buf);
}

References SLICE_SIZE.

Referenced by semver_render().

Here is the caller graph for this function:

concat_num()

static void concat_num ( char *  str, int  x, char *  sep  )

static

Renders

                                           {
  char buf[SLICE_SIZE] = {0};
  if (sep == NULL) sprintf(buf, "%d", x);
  else sprintf(buf, "%s%d", sep, x);
  strcat(str, buf);
}

References SLICE_SIZE.

Referenced by semver_numeric(), and semver_render().

Here is the caller graph for this function:

contains()

static int contains ( const char  c, const char *  matrix, size_t  len  )

static

                                                        {
  size_t x;
  for (x = 0; x < len; x++)
    if ((char) matrix[x] == c) return 1;
  return 0;
}

Referenced by char_to_int(), Slic3r::FFFTreeSupport::draw_areas(), Slic3r::find_nearby_points(), has_valid_chars(), Slic3r::FFFTreeSupport::move_inside_if_outside(), semver_clean(), and Slic3r::FFFTreeSupport::smooth_branch_areas().

Here is the caller graph for this function:

has_valid_chars()

static int has_valid_chars ( const char *  str, const char *  matrix  )

static

                                                      {
  size_t i, len, mlen;
  len = strlen(str);
  mlen = strlen(matrix);
 
  for (i = 0; i < len; i++)
    if (contains(str[i], matrix, mlen) == 0)
      return 0;
 
  return 1;
}

References contains().

Referenced by parse_int(), and semver_is_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

has_valid_length()

static int has_valid_length ( const char *  s )

static

Helpers

                                 {
  return strlen(s) <= MAX_SIZE;
}

References MAX_SIZE.

Referenced by semver_clean(), and semver_is_valid().

Here is the caller graph for this function:

parse_int()

static int parse_int ( const char *  s )

static

                          {
  int valid, num;
  valid = has_valid_chars(s, NUMBERS);
  if (valid == 0) return -1;
 
  num = strtol(s, NULL, 10);
  if (num > MAX_SAFE_INT) return -1;
 
  return num;
}

References has_valid_chars(), MAX_SAFE_INT, and NUMBERS.

Referenced by semver_numeric().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_slice()

static char * parse_slice ( char *  buf, char  sep  )

static

                                  {
  char *pr, *part;
  size_t plen;
 
  /* Find separator in buf */
  pr = strchr(buf, sep);
  if (pr == NULL) return NULL;
  /* Length from separator to end of buf */
  plen = strlen(pr);
 
  /* Copy from buf into new string */
  part = calloc(plen + 1, sizeof(*part));
  if (part == NULL) return NULL;
  memcpy(part, pr + 1, plen);
  /* Null terminate new string */
  part[plen] = '\0';
 
  /* Terminate buf where separator was */
  *pr = '\0';
 
  return part;
}

Referenced by semver_parse().

Here is the caller graph for this function:

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
	)

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:

strcut()

static int strcut ( char *  str, int  begin, int  len  )

static

Private helpers

                                       {
  size_t l;
  l = strlen(str);
 
  if((int)l < 0 || (int)l > MAX_SAFE_INT) return -1;
 
  if (len < 0) len = (int)l - begin + 1;
  if (begin + len > (int)l) len = (int)l - begin;
  memmove(str + begin, str + begin + len, l - len + 1 - begin);
 
  return len;
}

References MAX_SAFE_INT.

Referenced by semver_clean().

Here is the caller graph for this function:

Variable Documentation

MAX_SAFE_INT

const int MAX_SAFE_INT = (unsigned int) -1 >> 1

static

Referenced by parse_int(), and strcut().

MAX_SIZE

const size_t MAX_SIZE = sizeof(char) * 255

static

Referenced by has_valid_length().