kptions.c File Reference

#include "options.h"
#include "error.h"
#include "print.h"
#include <ctype.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

Include dependency graph for kptions.c:

Go to the source code of this file.

Macros
#define	OPTION(N, V, L, H, D)
#define	size_table   (sizeof table / sizeof *table)

Functions
const opt *	kissat_options_has (const char *name)
bool	kissat_parse_option_value (const char *val_str, int *res_ptr)
const char *	kissat_parse_option_name (const char *arg, const char *name)
void	kissat_init_options (void)
int	kissat_options_get (const char *name)

Variables
const opt *	kissat_options_begin = table
const opt *	kissat_options_end = table + size_table

Macro Definition Documentation

OPTION

#define OPTION	(		N,
			V,
			L,
			H,
			D )

Value:

{#N, (int) (V), D},

size_table

#define size_table   (sizeof table / sizeof *table)

Definition at line 31 of file kptions.c.

Function Documentation

kissat_init_options()

void kissat_init_options

(

void

)

Definition at line 178 of file kptions.c.

{ check_table_sorted (); }

Here is the caller graph for this function:

kissat_options_get()

int kissat_options_get

(

const char *

name

)

Definition at line 180 of file kptions.c.

                                          {
  const opt *const o = kissat_options_has (name);
  return o ? o->value : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kissat_options_has()

const opt * kissat_options_has

(

const char *

name

)

Definition at line 47 of file kptions.c.

                                                 {
  size_t l = 0, m, r = size_table;
  int tmp;
  opt const *o;
  KISSAT_assert (l < r);
  while (l + 1 < r) {
    m = l + (r - l) / 2;
    tmp = strcmp (name, (o = table + m)->name);
    if (tmp < 0)
      r = m;
    else if (tmp > 0)
      l = m;
    else
      return o;
  }
  o = table + l;
  tmp = strcmp (o->name, name);
  return tmp ? 0 : o;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kissat_parse_option_name()

const char * kissat_parse_option_name	(	const char *	arg,
		const char *	name )

Definition at line 161 of file kptions.c.

                                                                         {
  if (arg[0] != '-' || arg[1] != '-')
    return 0;
  char const *p = arg + 2, *q = name;
  if (p[0] == 'n' && p[1] == 'o' && p[2] == '-')
    return strcmp (p + 3, name) ? 0 : "0";
  while (*p && *p == *q)
    p++, q++;
  if (*q)
    return 0;
  if (*p != '=')
    return 0;
  return p + 1;
}

Here is the call graph for this function:

kissat_parse_option_value()

bool kissat_parse_option_value	(	const char *	val_str,
		int *	res_ptr )

Definition at line 67 of file kptions.c.

                                                                   {
  if (!strcmp (val_str, "true")) {
    *res_ptr = 1;
    return true;
  }
  if (!strcmp (val_str, "false")) {
    *res_ptr = 0;
    return true;
  }
  int sign = 1;
  char const *p = val_str;
  int ch = *p++;
  if (ch == '-') {
    sign = -1;
    ch = *p++;
  }
  if (!isdigit (ch)) // at least one digit
    return false;
  const unsigned max = -(unsigned) INT_MIN;
  unsigned res = ch - '0';
  while (isdigit ((ch = *p++))) {
    if (max / 10 < res)
      return false;
    res *= 10;
    const unsigned digit = ch - '0';
    if (max - digit < res)
      return false;
    res += digit;
    if (!res)
      return false; // invalid '00'
  }
  if (ch == 'e') // parse '13e5' etc.
  {
    if (!isdigit ((ch = *p++))) // at least one digit
      return false;
    if (res) {
      if (*p) // exactly one digit
        return false;
      const unsigned digit = ch - '0';
      for (unsigned i = 0; i < digit; i++) {
        if (max / 10 < res)
          return false;
        res *= 10;
      }
    } else // parse '0^123123123' etc.
    {
      while (isdigit (ch = *p++)) // arbitrary many digits
        ;
      if (ch)
        return false;
    }
  } else if (ch == '^') // parse '2^11' etc.
  {
    const unsigned base = res;
    if (!isdigit ((ch = *p++))) // at least one digit
      return false;
    unsigned exp = ch - '0';
    if (base < 2) // parse '0^123123123' etc.
    {
      while (isdigit (ch = *p++)) // arbitrary many digits
        ;
      if (ch)
        return false;
    } else if (isdigit (ch = *p++)) // parse '2^30' etc.
    {
      if (*p) // at most two digits
        return false;
      exp *= 10;
      const unsigned digit = ch - '0';
      exp += digit;
      if (!exp) // '2^00' invalid
        return false;
    } else if (ch)
      return false;
    if (exp)
      for (unsigned i = 1; i < exp; i++) {
        if (max / base < res)
          return false;
        res *= base;
      }
    else if (base)
      res = 1; // parse '3^0'
    else
      return false; // '0^0' invalid
  } else if (ch)
    return false;
  KISSAT_assert (res <= max);
  if (sign > 0 && res == max)
    return false;
  res *= sign;
  *res_ptr = res;
  return true;
}

Here is the call graph for this function:

Variable Documentation

kissat_options_begin

const opt* kissat_options_begin = table

Definition at line 33 of file kptions.c.

kissat_options_end

const opt* kissat_options_end = table + size_table

Definition at line 34 of file kptions.c.