コード例 #1
0
static void
cap_parser_text_cb (void           *user_data,
                    const XML_Char *s,
                    int             len)
{
    ParserData  *data;
    ParserState  state;
    gchar       *tmp;

    data = (ParserData *) user_data;

    /* text is not null terminated. */
    tmp = g_strndup (s, len);

    state = cap_parser_peek_state (data);

    switch (state) {
    case PARSER_STATE_MEMORY_TYPE:
        data->memory_type = g_strdup (tmp);
        break;
    case PARSER_STATE_MEMORY_FREE:
        data->memory_free = parse_long (tmp, &data->memory_has_free);
        break;
    case PARSER_STATE_MEMORY_USED:
        data->memory_used = parse_long (tmp, &data->memory_has_used);
        break;

    default:
        break;
    }

    g_free (tmp);
}
コード例 #2
0
ファイル: find.c プロジェクト: codernator/creepy-garbanzo
/***************************************************************************
 *	cmp_fn_index
 ***************************************************************************/
bool cmp_fn_index(long bit, const char *arg, const struct flag_type *table, struct buf_type *buf)
{
    int iter;

    if (buf != NULL) {
        char flag[MAX_STRING_LENGTH];
        int col = 0;

        add_buf(buf, "\n\r     ");
        for (iter = 0; table[iter].name != NULL; iter++) {
            sprintf(flag, "%-19.18s", table[iter].name);
            add_buf(buf, flag);
            if (++col % 3 == 0)
                add_buf(buf, "\n\r     ");
        }

        if (col % 3 != 0)
            add_buf(buf, "\n\r");
    } else {
        while (isspace((int)*arg) || arg[0] == '=')
            arg++;

        if (is_number(arg)) {
            return IS_SET(bit, parse_long(arg)) > 0;
        } else {
            for (iter = 0; table[iter].name != NULL; iter++)
                if (!str_prefix(arg, table[iter].name))
                    return bit == table[iter].bit;
        }
    }

    return false;
}
コード例 #3
0
ファイル: http.c プロジェクト: mogi57/nmap-5.61TEST4-android
/* Returns 0 on success and nonzero on failure. */
int http_parse_status_line(const char *line, struct http_response *response)
{
    const char *p, *q;

    http_response_init(response);

    /* Version. */
    p = parse_http_version(line, &response->version);
    if (p == line)
        return -1;
    while (*p == ' ')
        p++;

    /* Status code. */
    errno = 0;
    response->code = parse_long(p, (char **) &q);
    if (errno != 0 || q == p)
        return -1;
    p = q;

    /* Reason phrase. */
    while (*p == ' ')
        p++;
    q = p;
    while (!is_crlf(q))
        q++;
    /* We expect that the CRLF ends the string. */
    if (*skip_crlf(q) != '\0')
        return -1;
    response->phrase = mkstr(p, q);

    return 0;
}
コード例 #4
0
ファイル: config.cpp プロジェクト: dawehner/FARGO-Viewer
/**
	Get a value as int

	\param key key
	\param value value to read
	\returns value
*/
static int as_int(const char *key, const char *value)
{
	long ret = 0;
	if (!parse_long(value, &ret))
		die_bad_config(key);
	return ret;
}
コード例 #5
0
ファイル: main.c プロジェクト: bruceg/bglibs
static int parse_args(int argc, char* argv[])
{
  int i;
  int j;
  build_options();
  for(i = 1; i < argc; i++) {
    const char* arg = argv[i];
    // Stop at the first non-option argument
    if(arg[0] != '-')
      break;
    // Stop after the first "-" or "--"
    if(arg[1] == '\0' ||
       (arg[1] == '-' && arg[2] == '\0')) {
      i++;
      break;
    }
    j = (arg[1] != '-') ?
      parse_short(argc-i, argv+i) :
      parse_long(argv+i);
    if(j < 0)
      usage(1, 0);
    else
      i += j;
  }
  return i;
}
コード例 #6
0
ファイル: dbg_config.cpp プロジェクト: ben-jose/ben-jose
void
config_reader::parse_debug_line(row<long>& dbg_line, ch_string& str_ln){
#ifdef FULL_DEBUG
	bj_ostream& os = bj_out;
	MARK_USED(os);
	
	const char* pt_in = str_ln.c_str();

	dbg_line.clear();
	
	long num_ln = 0;

	if(isalnum(*pt_in)){
		skip_whitespace(pt_in, num_ln);
		while(isdigit(*pt_in) || isspace(*pt_in)){
			if(isspace(*pt_in)){
				pt_in++;
				continue;
			}
			//os << pt_in << "$\n";
			
			long val = parse_long(pt_in, num_ln); 
			//skip_whitespace(pt_in, num_ln);
	
			dbg_line.push(val);
		}
	} else {
		skip_line(pt_in, num_ln);
	}
#endif
}
コード例 #7
0
ファイル: check_setuid.c プロジェクト: millisetan/apue
int main(int argc, char *argv[]) {
    if (argc < 2 || argc > 3) {
        usage(argv[0]);
    }
    int uid_arg_idx = 1;
    bool use_seteuid = false;
    if (argc == 3) {
        if (strcmp("-e", argv[1]) == 0) {
            uid_arg_idx = 2;
            use_seteuid = true;
        } else {
            usage(argv[0]);
        }
    }

    long target_uid = parse_long(argv[uid_arg_idx]);
    if (target_uid < 0) {
        err_quit("Target UID should be non-negative");
    }

    print_ids();
    printf("\nCalling %s(%ld)\n\n",
           use_seteuid ? "seteuid" : "setuid",
           target_uid);
    if (use_seteuid) {
        sys_chk(seteuid(target_uid));
    } else {
        sys_chk(setuid(target_uid));
    }
    print_ids();

    return EXIT_SUCCESS;
}
コード例 #8
0
ファイル: lwan-config.c プロジェクト: nining/lwan
int parse_int(const char *value, int default_value)
{
    long long_value = parse_long(value, default_value);

    if ((long)(int)long_value != long_value)
        return default_value;

    return (int)long_value;
}
コード例 #9
0
ファイル: frontend.c プロジェクト: stefanorf/pltb
static int parse_int(char *str)
{
    long val = parse_long(str);
    if (val <= INT_MAX && val >= INT_MIN) {
        return (int)val;
    } else {
        return -1;
    }
}
コード例 #10
0
ファイル: taiutc2table.c プロジェクト: jani-hautamaki/gsim
static int parse_line(
    const char *linebuf,
    int *year,
    int *month,
    int *day,
    double *delta
) {
	char s[0x100]; // for substrings

	long tmp;

	substr(s, linebuf, 1, 4); // year
	if (!parse_long(s, &tmp)) {
		fprintf(stderr, "cannot parse year: \"%s\"\n", s);
		return 0;
	}
	*year = (int) tmp;

	substr(s, linebuf, 6, 3); // month name abbr
	if (!parse_month(s, &tmp)) {
		fprintf(stderr, "cannot parse month: \"%s\"\n", s);
		return 0;
	}
	*month = (int) tmp;

	substr(s, linebuf, 10, 2); // day
	if (!parse_long(s, &tmp)) {
		fprintf(stderr, "cannot parse day: \"%s\"\n", s);
		return 0;
	}
	*day = (int) tmp;

	substr(s, linebuf, 36, 13); // tai-utc delta
	if (!parse_double(s, delta)) {
		fprintf(stderr, "cannot parse delta: %s\n", s);
		return 0;
	}
	return 1;

//         1         2         3         4         5         6         7         8
//12345678901234567890123456789012345678901234567890123456789012345678901234567890
//                                    1234567890123
// 2012 JUL  1 =JD 2456109.5  TAI-UTC=  35.0       S + (MJD - 41317.) X 0.0      S
}
コード例 #11
0
ファイル: nsock_proxy.c プロジェクト: 4nY0n0m0u5/nmap
static int uri_parse_authority(const char *authority, struct uri *uri) {
  const char *portsep;
  const char *host_start, *host_end;
  char *tail;

  /* We do not support "user:pass@" userinfo. The proxy has no use for it. */
  if (strchr(authority, '@') != NULL)
    return -1;

  /* Find the beginning and end of the host. */
  host_start = authority;

  if (*host_start == '[') {
    /* IPv6 address in brackets. */
    host_start++;
    host_end = strchr(host_start, ']');

    if (host_end == NULL)
      return -1;

    portsep = host_end + 1;

    if (!(*portsep == ':' || *portsep == '\0'))
      return -1;

  } else {
    portsep = strrchr(authority, ':');

    if (portsep == NULL)
      portsep = strchr(authority, '\0');
    host_end = portsep;
  }

  /* Get the port number. */
  if (*portsep == ':' && *(portsep + 1) != '\0') {
    long n;

    errno = 0;
    n = parse_long(portsep + 1, &tail);
    if (errno || *tail || (tail == (portsep + 1)) || !IN_RANGE(n, 1, 65535))
      return -1;
    uri->port = n;
  } else {
    uri->port = -1;
  }

  /* Get the host. */
  uri->host = mkstr(host_start, host_end);
  if (percent_decode(uri->host) < 0) {
    free(uri->host);
    uri->host = NULL;
    return -1;
  }

  return 1;
}
コード例 #12
0
ファイル: slscanf.c プロジェクト: ebichu/dd-wrt
static int parse_int (SLFUTURE_CONST char **sp, SLFUTURE_CONST char *smax, int *np,
		      long base, unsigned char map[256])
{
   long n;
   int status;

   if (1 == (status = parse_long (sp, smax, &n, base, map)))
     *np = (int) n;
   return status;
}
コード例 #13
0
ファイル: fc.c プロジェクト: gaurav0216/FCtoolbar
int main(int argc, char * argv[])
{
  
  long_index = 0;
  init_args();
  parse_long(argc, argv);
  printf("Correlation method is %d\n",argum.correlation_method);
  print_args();
  return 0;
}
コード例 #14
0
bool parse_cg_line(sk_str *source, sk_cg_geometry *buffer)
{
    if (!source || !buffer)
    {
        return false;
    }

    char delimiter = ' ';
    SINT_64 coordinates[4] = { 0 };

    sk_iterator tokens;
    if (!sk_str_split(&tokens, source, delimiter))
    {
        return false;
    }

    char *token;
    sk_str str_token;
    SINT_64 *curr_coordinate = coordinates;
    int read = 0;
    while (read < 4 && tokens.has_next(&tokens))
    {
        token = tokens.next(&tokens);
        if (!token)
        {
            continue;
        }

        sk_str_init(&str_token, token, 8);

        if (!parse_long(&str_token, 0, curr_coordinate))
        {
            sk_str_destroy(&str_token);
            tokens.destroy(&tokens);
            return false;
        }

        sk_str_destroy(&str_token);
        ++curr_coordinate;
        ++read;
    }

    buffer->type = LINE;
    buffer->geometry.line.a.x = coordinates[0];
    buffer->geometry.line.a.y = coordinates[1];
    buffer->geometry.line.b.x = coordinates[2];
    buffer->geometry.line.b.y = coordinates[3];

    tokens.destroy(&tokens);

    return true;
}
コード例 #15
0
ファイル: x-idle.c プロジェクト: benizi/dotfiles
int main(int argc, char **argv) {
  long started, wait_idle_ms, timeout_ms;
  int event_base, error_base, timed_out = 0;

  if (argc > 1) wait_idle_ms = parse_long(argv[1], DEFAULT_WAIT_MS);
  if (argc > 2) timeout_ms = parse_long(argv[2], DEFAULT_TIMEOUT_MS);

  started = now();
  Display *disp = XOpenDisplay(NULL);
  OK(disp);
  OK(XScreenSaverQueryExtension(disp, &event_base, &error_base));
  XScreenSaverInfo *info = XScreenSaverAllocInfo();
  OK(info);
  while (1) {
    if (now() >= started + timeout_ms * NANOS / MILLIS) BREAK(timed_out);
    OK(XScreenSaverQueryInfo(disp, DefaultRootWindow(disp), info));
    if (info->idle >= wait_idle_ms) break;
  }
  XFree(info);
  XCloseDisplay(disp);
  exit(timed_out ? EXIT_FAILURE : EXIT_SUCCESS);
}
コード例 #16
0
ファイル: bench.c プロジェクト: BitBondtmUK/liboqs
static bool parse_uint32_t(uint32_t* value, const char* arg) {
  long tmp = 0;
  if (!parse_long(&tmp, arg)) {
    return false;
  }

  if (tmp < 0 || (unsigned long)tmp > UINT32_MAX) {
    return false;
  }

  *value = tmp;
  return true;
}
コード例 #17
0
ファイル: util.c プロジェクト: kaoudis/tor-dock
/** Parse a string of the form "host[:port]" from <b>addrport</b>.  If
 * <b>address</b> is provided, set *<b>address</b> to a copy of the
 * host portion of the string.  If <b>addr</b> is provided, try to
 * resolve the host portion of the string and store it into
 * *<b>addr</b> (in host byte order).  If <b>port_out</b> is provided,
 * store the port number into *<b>port_out</b>, or 0 if no port is given.
 * If <b>port_out</b> is NULL, then there must be no port number in
 * <b>addrport</b>.
 * Return 0 on success, -1 on failure.
 */
int
parse_addr_port(int severity, const char *addrport, char **address,
                uint32_t *addr, uint16_t *port_out)
{
  const char *colon;
  char *_address = NULL;
  int _port;
  int ok = 1;

  assert(addrport);

  colon = strchr(addrport, ':');
  if (colon) {
    _address = tor_strndup(addrport, colon-addrport);
    _port = (int) parse_long(colon+1,10,1,65535,NULL,NULL);
    if (!_port) {
      fprintf(stderr, "Port %s out of range\n", colon+1);
      ok = 0;
    }
    if (!port_out) {
      fprintf(stderr, "Port %s given on %s when not required\n",
	      colon+1, addrport);
      ok = 0;
    }
  } else {
    _address = strdup(addrport);
    _port = 0;
  }

  if (addr) {
    /* There's an addr pointer, so we need to resolve the hostname. */
    if (lookup_hostname(_address,addr)) {
      fprintf(stderr, "Couldn't look up %s\n", _address);
      ok = 0;
      *addr = 0;
    }
  }

  if (address && ok) {
    *address = _address;
  } else {
    if (address)
      *address = NULL;
    free(_address);
  }
  if (port_out)
    *port_out = ok ? ((uint16_t) _port) : 0;

  return ok ? 0 : -1;
}
コード例 #18
0
ファイル: lab4.c プロジェクト: gtugablue/LCOM-Racinix
static int proc_args(int argc, char *argv[]) {

	unsigned long cnt, idle_time, tolerance;
	long length;

	/* check the function to test: if the first characters match, accept it */
	if (strncmp(argv[1], "packet", strlen("packet")) == 0) {
		if( argc != 3 ) {
			printf("mouse: wrong no of arguments for test of test_packet() \n");
			return 1;
		}
		if( (cnt = parse_ulong(argv[2], 10)) == ULONG_MAX )
			return 1;
		printf("mouse:: test_packet(%lu)\n",
				cnt);
		return test_packet(cnt);
	} else if (strncmp(argv[1], "async", strlen("async")) == 0) {
		if( argc != 3 ) {
			printf("mouse: wrong no of arguments for test_async() \n");
			return 1;
		}
		if( (idle_time = parse_ulong(argv[2], 10)) == ULONG_MAX )
			return 1;
		printf("mouse:: test_async(%lu)\n",
				idle_time);
		return test_async(idle_time);
	} else if (strncmp(argv[1], "config", strlen("config")) == 0) {
		if( argc != 2 ) {
			printf("mouse: wrong no of arguments for test_config() \n");
			return 1;
		}
		printf("mouse:: test_config()\n");
		return test_config();
	} else if (strncmp(argv[1], "gesture", strlen("gesture")) == 0) {
		if( argc != 4 ) {
			printf("mouse: wrong no of arguments for test_gesture() \n");
			return 1;
		}
		if( (length = parse_long(argv[2], 10)) == LONG_MAX )
			return 1;
		if( (tolerance = parse_ulong(argv[3], 10)) == ULONG_MAX )
					return 1;
		printf("mouse:: test_gesture(%ld, %lu)\n",
				length, tolerance);
		return test_gesture(length, tolerance);
	} else {
		printf("mouse: non valid function \"%s\" to test\n", argv[1]);
		return 1;
	}
}
コード例 #19
0
ファイル: http.c プロジェクト: mogi57/nmap-5.61TEST4-android
/* Returns the character pointer after the HTTP version, or s if there was a
   parse error. */
static const char *parse_http_version(const char *s, enum http_version *version)
{
    const char *PREFIX = "HTTP/";
    const char *p, *q;
    long major, minor;

    *version = HTTP_UNKNOWN;

    p = s;
    if (memcmp(p, PREFIX, strlen(PREFIX)) != 0)
        return s;
    p += strlen(PREFIX);

    /* Major version. */
    errno = 0;
    major = parse_long(p, (char **) &q);
    if (errno != 0 || q == p)
        return s;

    p = q;
    if (*p != '.')
        return s;
    p++;

    /* Minor version. */
    errno = 0;
    minor = parse_long(p, (char **) &q);
    if (errno != 0 || q == p)
        return s;

    if (major == 1 && minor == 0)
        *version = HTTP_10;
    else if (major == 1 && minor == 1)
        *version = HTTP_11;

    return q;
}
コード例 #20
0
ファイル: docopt.c プロジェクト: rockwolf/c
int parse_args(Tokens *ts, Elements *elements) {
    int ret;

    while (ts->current != NULL) {
        if (strcmp(ts->current, "--") == 0) {
            ret = parse_doubledash(ts, elements);
            if (!ret) break;
        } else if (ts->current[0] == '-' && ts->current[1] == '-') {
            ret = parse_long(ts, elements);
        } else if (ts->current[0] == '-' && ts->current[1] != '\0') {
            ret = parse_shorts(ts, elements);
        } else
            ret = parse_argcmd(ts, elements);
        if (ret) return ret;
    }
    return 0;
}
コード例 #21
0
ファイル: mtbl_merge.c プロジェクト: edmonds/mtbl
static bool
parse_arg_block_size(const char *arg)
{
	long int arg_block_size = 0;

	if (getenv("MTBL_MERGE_BLOCK_SIZE") != NULL) {
		fprintf(stderr,
			"%s: Error: specify block size via command-line or environment, not both\n",
			program_name);
		return false;
	}

	if (!parse_long(arg, &arg_block_size))
		return false;

	opt_block_size = arg_block_size;
	return true;
}
コード例 #22
0
int getopt_long(int argc, char *argv[],
      const char *optstring, const struct option *longopts, int *longindex)
{
   int short_index, long_index;

   (void)longindex;

   if (optind == 0)
      optind = 1;

   if (argc == 1)
      return -1;

   short_index = find_short_index(&argv[optind]);
   long_index  = find_long_index(&argv[optind]);

   /* We're done here. */
   if (short_index == -1 && long_index == -1)
      return -1;

   /* Reorder argv so that non-options come last.
    * Non-POSIXy, but that's what getopt does by default. */
   if ((short_index > 0) && ((short_index < long_index) || (long_index == -1)))
   {
      shuffle_block(&argv[optind], &argv[optind + short_index], &argv[argc]);
      short_index = 0;
   }
   else if ((long_index > 0) && ((long_index < short_index)
            || (short_index == -1)))
   {
      shuffle_block(&argv[optind], &argv[optind + long_index], &argv[argc]);
      long_index = 0;
   }

   rarch_assert(short_index == 0 || long_index == 0);

   if (short_index == 0)
      return parse_short(optstring, &argv[optind]);
   else if (long_index == 0)
      return parse_long(longopts, &argv[optind]);
   else
      return '?';
}
コード例 #23
0
ファイル: mjd2taiutcdelta.c プロジェクト: jani-hautamaki/gsim
int main(int argc, char *argv[]) {

	if (argc < 2) {
		fprintf(stderr, "Usage: %s <daynum>\n", argv[0]);
		exit(EXIT_FAILURE);
	}

	// Arguments
	long daynum;

	if (!parse_long(argv[1], &daynum)) {
		fprintf(stderr, "Not an integer: %s\n", argv[1]);
		exit(EXIT_FAILURE);
	}

	int delta = sun_delta_tai_utc(daynum);

	printf("On Modified Julian Day %ld the difference TAI-UTC = %d s\n",
	    daynum, delta);

	exit(EXIT_SUCCESS);
}
コード例 #24
0
ファイル: http.c プロジェクト: mogi57/nmap-5.61TEST4-android
static int http_header_get_content_length(const struct http_header *header, unsigned long *content_length)
{
    char *content_length_s;
    char *tail;
    int code;

    content_length_s = http_header_get_first(header, "Content-Length");
    if (content_length_s == NULL) {
        *content_length = 0;
        return 0;
    }

    code = 0;

    errno = 0;
    *content_length = parse_long(content_length_s, (char **) &tail);
    if (errno != 0 || *tail != '\0' || tail == content_length_s)
        code = 400;
    free(content_length_s);

    return code;
}
コード例 #25
0
ファイル: slscanf.c プロジェクト: ebichu/dd-wrt
/* FIXME: This function does not handle LONG_LONG */
int _pSLang_sscanf (void)
{
   int num;
   unsigned int num_refs;
   char *format;
   char *input_string, *input_string_max;
   SLFUTURE_CONST char *f, *s;
   unsigned char map8[256], map10[256], map16[256];

   if (SLang_Num_Function_Args < 2)
     {
	_pSLang_verror (SL_INVALID_PARM, "Int_Type sscanf (str, format, ...)");
	return -1;
     }
   
   num_refs = (unsigned int) SLang_Num_Function_Args;
   if (-1 == SLreverse_stack (num_refs))
     return -1;
   num_refs -= 2;

   if (-1 == SLang_pop_slstring (&input_string))
     return -1;

   if (-1 == SLang_pop_slstring (&format))
     {
	SLang_free_slstring (input_string);
	return -1;
     }
   
   f = format;
   s = input_string;
   input_string_max = input_string + strlen (input_string);

   init_map (map8, 8);
   init_map (map10, 10);
   init_map (map16, 16);

   num = 0;

   while (num_refs != 0)
     {
	SLang_Object_Type obj;
	SLang_Ref_Type *ref;
	SLFUTURE_CONST char *smax;
	unsigned char *map;
	int base;
	int no_assign;
	int is_short;
	int is_long;
	int status;
	char chf;
	unsigned int width;
	int has_width;

	chf = *f++;

	if (chf == 0)
	  {
	     /* Hmmm....  what is the most useful thing to do?? */
#if 1
	     break;
#else
	     _pSLang_verror (SL_INVALID_PARM, "sscanf: format not big enough for output list");
	     goto return_error;
#endif
	  }

	if (isspace (chf))
	  {
	     char *s1 = _pSLskip_whitespace (s);
	     if (s1 == s)
	       break;
	     s = s1;
	     continue;
	  }
	
	if ((chf != '%')
	    || ((chf = *f++) == '%'))
	  {
	     if (*s != chf)
	       break;
	     s++;
	     continue;
	  }

	no_assign = 0;
	is_short = 0;
	is_long = 0;
	width = 0;
	smax = input_string_max;

	/* Look for the flag character */
	if (chf == '*')
	  {
	     no_assign = 1;
	     chf = *f++;
	  }
	
	/* Width */
	has_width = isdigit (chf);
	if (has_width)
	  {
	     f--;
	     (void) parse_uint (&f, f + strlen(f), &width, 10, map10);
	     chf = *f++;
	  }

	/* Now the type modifier */
	switch (chf)
	  {
	   case 'h':
	     is_short = 1;
	     chf = *f++;
	     break;
	     
	   case 'L':		       /* not implemented */
	   case 'l':
	     is_long = 1;
	     chf = *f++;
	     break;
	  }

	status = -1;

	if ((chf != 'c') && (chf != '['))
	  {
	     s = _pSLskip_whitespace (s);
	     if (*s == 0)
	       break;
	  }

	if (has_width)
	  {
	     if (width > (unsigned int) (input_string_max - s))
	       width = (unsigned int) (input_string_max - s);
	     smax = s + width;
	  }
	     
	/* Now the format descriptor */

	map = map10;
	base = 10;

	try_again:		       /* used by i, x, and o, conversions */
	switch (chf)
	  {
	   case 0:
	     _pSLang_verror (SL_INVALID_PARM, "sscanf: Unexpected end of format");
	     goto return_error;
	   case 'D':
	     is_long = 1;
	   case 'd':
	     if (is_short)
	       {
		  obj.o_data_type = SLANG_SHORT_TYPE;
		  status = parse_short (&s, smax, &obj.v.short_val, base, map);
	       }
	     else if (is_long)
	       {
		  obj.o_data_type = SLANG_LONG_TYPE;
		  status = parse_long (&s, smax, &obj.v.long_val, base, map);
	       }
	     else
	       {
		  obj.o_data_type = SLANG_INT_TYPE;
		  status = parse_int (&s, smax, &obj.v.int_val, base, map);
	       }
	     break;
	     

	   case 'U':
	     is_long = 1;
	   case 'u':
	     if (is_short)
	       {
		  obj.o_data_type = SLANG_USHORT_TYPE;
		  status = parse_ushort (&s, smax, &obj.v.ushort_val, base, map);
	       }
	     else if (is_long)
	       {
		  obj.o_data_type = SLANG_ULONG_TYPE;
		  status = parse_ulong (&s, smax, &obj.v.ulong_val, base, map);
	       }
	     else
	       {
		  obj.o_data_type = SLANG_INT_TYPE;
		  status = parse_uint (&s, smax, &obj.v.uint_val, base, map);
	       }
	     break;

	   case 'I':
	     is_long = 1;
	   case 'i':
	     if ((s + 1 >= smax)
		 || (*s != 0))
	       chf = 'd';
	     else if (((s[1] == 'x') || (s[1] == 'X'))
		      && (s + 2 < smax))
	       {
		  s += 2;
		  chf = 'x';
	       }
	     else chf = 'o';
	     goto try_again;
	     
	   case 'O':
	     is_long = 1;
	   case 'o':
	     map = map8;
	     base = 8;
	     chf = 'd';
	     goto try_again;
	     
	   case 'X':
	     is_long = 1;
	   case 'x':
	     base = 16;
	     map = map16;
	     chf = 'd';
	     goto try_again;

	   case 'E':
	   case 'F':
	     is_long = 1;
	   case 'e':
	   case 'f':
	   case 'g':
#if SLANG_HAS_FLOAT
	     if (is_long)
	       {
		  obj.o_data_type = SLANG_DOUBLE_TYPE;
		  status = parse_double (&s, smax, &obj.v.double_val);
	       }
	     else
	       {
		  obj.o_data_type = SLANG_FLOAT_TYPE;
		  status = parse_float (&s, smax, &obj.v.float_val);
	       }
#else
	     _pSLang_verror (SL_NOT_IMPLEMENTED,
			   "This version of the S-Lang does not support floating point");
	     status = -1;
#endif
	     break;
		  
	   case 's':
	     obj.o_data_type = SLANG_STRING_TYPE;
	     status = parse_string (&s, smax, &obj.v.s_val);
	     break;
	     
	   case 'c':
	     if (has_width == 0)
	       {
		  obj.o_data_type = SLANG_UCHAR_TYPE;
		  obj.v.uchar_val = *s++;
		  status = 1;
		  break;
	       }
	     obj.o_data_type = SLANG_STRING_TYPE;
	     status = parse_bstring (&s, smax, &obj.v.s_val);
	     break;
	     
	   case '[':
	     obj.o_data_type = SLANG_STRING_TYPE;
	     status = parse_range (&s, smax, &f, &obj.v.s_val);
	     break;
	     
	   case 'n':
	     obj.o_data_type = SLANG_UINT_TYPE;
	     obj.v.uint_val = (unsigned int) (s - input_string);
	     status = 1;
	     break;
	     
	   default:
	     status = -1;
	     _pSLang_verror (SL_NOT_IMPLEMENTED, "format specifier '%c' is not supported", chf);
	     break;
	  }
	
	if (status == 0)
	  break;

	if (status == -1)
	  goto return_error;

	if (no_assign)
	  {
	     SLang_free_object (&obj);
	     continue;
	  }

	if (-1 == SLang_pop_ref (&ref))
	  {
	     SLang_free_object (&obj);
	     goto return_error;
	  }
	
	if (-1 == SLang_push (&obj))
	  {
	     SLang_free_object (&obj);
	     SLang_free_ref (ref);
	     goto return_error;
	  }
	
	if (-1 == _pSLang_deref_assign (ref))
	  {
	     SLang_free_ref (ref);
	     goto return_error;
	  }
	SLang_free_ref (ref);

	num++;
	num_refs--;
     }

   if (-1 == SLdo_pop_n (num_refs))
     goto return_error;
   
   SLang_free_slstring (format);
   SLang_free_slstring (input_string);
   return num;

   return_error:
   /* NULLS ok */
   SLang_free_slstring (format);
   SLang_free_slstring (input_string);
   return -1;
}
コード例 #26
0
ファイル: slscanf.c プロジェクト: ebichu/dd-wrt
static int parse_ulong (SLFUTURE_CONST char **sp, SLFUTURE_CONST char *smax, unsigned long *np,
			long base, unsigned char map[256])
{
   return parse_long (sp, smax, (long *) np, base, map);
}
コード例 #27
0
ファイル: server.c プロジェクト: andyturk/openocd
/* FIX! make service return error instead of invoking exit() */
int add_service(char *name,
	const char *port,
	int max_connections,
	new_connection_handler_t new_connection_handler,
	input_handler_t input_handler,
	connection_closed_handler_t connection_closed_handler,
	void *priv)
{
	struct service *c, **p;
	int so_reuseaddr_option = 1;

	c = malloc(sizeof(struct service));

	c->name = strdup(name);
	c->port = strdup(port);
	c->max_connections = 1;	/* Only TCP/IP ports can support more than one connection */
	c->fd = -1;
	c->connections = NULL;
	c->new_connection = new_connection_handler;
	c->input = input_handler;
	c->connection_closed = connection_closed_handler;
	c->priv = priv;
	c->next = NULL;
	long portnumber;
	if (strcmp(c->port, "pipe") == 0)
		c->type = CONNECTION_STDINOUT;
	else {
		char *end;
		portnumber = strtol(c->port, &end, 0);
		if (!*end && (parse_long(c->port, &portnumber) == ERROR_OK)) {
			c->portnumber = portnumber;
			c->type = CONNECTION_TCP;
		} else
			c->type = CONNECTION_PIPE;
	}

	if (c->type == CONNECTION_TCP) {
		c->max_connections = max_connections;

		c->fd = socket(AF_INET, SOCK_STREAM, 0);
		if (c->fd == -1) {
			LOG_ERROR("error creating socket: %s", strerror(errno));
			exit(-1);
		}

		setsockopt(c->fd,
			SOL_SOCKET,
			SO_REUSEADDR,
			(void *)&so_reuseaddr_option,
			sizeof(int));

		socket_nonblock(c->fd);

		memset(&c->sin, 0, sizeof(c->sin));
		c->sin.sin_family = AF_INET;
		c->sin.sin_addr.s_addr = INADDR_ANY;
		c->sin.sin_port = htons(c->portnumber);

		if (bind(c->fd, (struct sockaddr *)&c->sin, sizeof(c->sin)) == -1) {
			LOG_ERROR("couldn't bind to socket: %s", strerror(errno));
			exit(-1);
		}

#ifndef _WIN32
		int segsize = 65536;
		setsockopt(c->fd, IPPROTO_TCP, TCP_MAXSEG,  &segsize, sizeof(int));
#endif
		int window_size = 128 * 1024;

		/* These setsockopt()s must happen before the listen() */

		setsockopt(c->fd, SOL_SOCKET, SO_SNDBUF,
			(char *)&window_size, sizeof(window_size));
		setsockopt(c->fd, SOL_SOCKET, SO_RCVBUF,
			(char *)&window_size, sizeof(window_size));

		if (listen(c->fd, 1) == -1) {
			LOG_ERROR("couldn't listen on socket: %s", strerror(errno));
			exit(-1);
		}
	} else if (c->type == CONNECTION_STDINOUT) {
		c->fd = fileno(stdin);

#ifdef _WIN32
		/* for win32 set stdin/stdout to binary mode */
		if (_setmode(_fileno(stdout), _O_BINARY) < 0)
			LOG_WARNING("cannot change stdout mode to binary");
		if (_setmode(_fileno(stdin), _O_BINARY) < 0)
			LOG_WARNING("cannot change stdin mode to binary");
		if (_setmode(_fileno(stderr), _O_BINARY) < 0)
			LOG_WARNING("cannot change stderr mode to binary");
#else
		socket_nonblock(c->fd);
#endif
	} else if (c->type == CONNECTION_PIPE) {
#ifdef _WIN32
		/* we currenty do not support named pipes under win32
		 * so exit openocd for now */
		LOG_ERROR("Named pipes currently not supported under this os");
		exit(1);
#else
		/* Pipe we're reading from */
		c->fd = open(c->port, O_RDONLY | O_NONBLOCK);
		if (c->fd == -1) {
			LOG_ERROR("could not open %s", c->port);
			exit(1);
		}
#endif
	}

	/* add to the end of linked list */
	for (p = &services; *p; p = &(*p)->next)
		;
	*p = c;

	return ERROR_OK;
}
コード例 #28
0
ファイル: frontend.c プロジェクト: stefanorf/pltb
int main (int argc, char **argv)
{
#if MPI_MASTER_WORKER
    int process_id;
    int n_processes;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &process_id);
    MPI_Comm_size(MPI_COMM_WORLD, &n_processes);
#endif

    static const unsigned NO_EXTRA_MODEL[] = {};
    const unsigned        EXTRA_GTR[] = { model_index_GTR };

    /* configuration */
    pltb_config_t config;

    /* pltb config */
    configure_attr_defaults(&config);
    config.extra_models   = (unsigned*)&NO_EXTRA_MODEL;
    config.n_extra_models = 0;
    config.base_freq_kind = EMPIRICAL;

    /* pltb target */
    char *datafile      = NULL;  /* illegal default => to be set */

    /* model space config */
    int  upper_bound    = 203;
    int  lower_bound    = 0;

    /* cli related configuration and variables */
    opterr = 0; /* avoid errors generated by getopt */
    int error = 0;
    int opt_index;
    int c;

    bool print_config   = false;
    bool print_progress = false;

    while (1) {
        static struct option long_options[] = {
            {"data",            required_argument, 0, 'f'},
            {"opt-base-freq",   no_argument,       0, 'b'},
            {"upper-bound",     required_argument, 0, 'u'},
            {"lower-bound",     required_argument, 0, 'l'},
            {"npthreads",       required_argument, 0, 'n'},
            {"npthreads-tree",  required_argument, 0, 's'},
            {"rseed",           required_argument, 0, 'r'},
            {"config",          no_argument,       0, 'c'},
            {"progress",        no_argument,       0, 'p'},
            {"with-gtr",        no_argument,       0, 'g'},
            {0,                 0,                 0, 0  }
        };

        c = getopt_long(argc, argv, "cpbgf:u:l:n:s:r:", long_options, &opt_index);

        if (c == -1) break;
        switch (c) {
        case 'b':
            config.base_freq_kind = OPTIMIZED;
            break;
        case 'f':
            if (access(optarg, R_OK) != -1) {
                datafile = optarg;
            } else {
                ERROR("Illegal dataset file: %s\n", optarg);
                error = 1;
            }
            break;
        case 'u':
            upper_bound = parse_int(optarg);
            if (upper_bound < 1 || upper_bound > 202) {
                ERROR("Illegal value for upper matrix index bound: %s\n", optarg);
                error = 1;
            }
            break;
        case 'l':
            lower_bound = parse_int(optarg);
            if (lower_bound < 0 || lower_bound > 202) {
                ERROR("Illegal value for lower matrix index bound: %s\n", optarg);
                error = 1;
            }
            break;
        case 'n':
            config.attr_model_eval.numberOfThreads = parse_int(optarg);
            if (config.attr_model_eval.numberOfThreads < 0) {
                ERROR("Negative value for number of pthreads: %s\n", optarg);
                error = 1;
            }
            break;
        case 's':
            config.attr_tree_search.numberOfThreads = parse_int(optarg);
            if (config.attr_tree_search.numberOfThreads < 0) {
                ERROR("Negative value for number of pthreads: %s\n", optarg);
                error = 1;
            }
            break;
        case 'r':
            config.attr_model_eval.randomNumberSeed = parse_long(optarg);
            config.attr_tree_search.randomNumberSeed = parse_long(optarg);
            break;
        case 'c':
            print_config = true;
            break;
        case 'p':
            print_progress = true;
            break;
        case 'g':
            config.n_extra_models = 1;
            config.extra_models = (unsigned*)&EXTRA_GTR;
            break;
        case 0:
            /* all long options return a value != 0 */
            assert(false);
            break;
        default:
            error = 1;
            break;
        }
    }

    while (optind < argc) {
        error = 1;
        ERROR("Not recognized option: %s\n", argv[optind++]);
        break;
    }

    if (!error && !datafile) {
        ERROR("Missing required file argument\n");
        error = 1;
    }

    if (!error) {
        if (lower_bound >= upper_bound) {
            ERROR("Upper bound greater then the lower bound.\n");
            error = 1;
        }
    }

    if(!error)
    {
#if MPI_MASTER_WORKER
        if (print_config && process_id == 0) {
#else
        if (print_config) {
#endif
            DBG("Configuration\n");
            DBG("\tDataset: %s\n", datafile);
            DBG("\tRandom number seeds: %#lx/%#lx\n", config.attr_model_eval.randomNumberSeed, config.attr_tree_search.randomNumberSeed);
            DBG("\tBase frequencies: ");
            switch (config.base_freq_kind) {
            case EMPIRICAL:
                DBG("Empirical");
                break;
            case OPTIMIZED:
                DBG("Optimized");
                break;
            case EQUAL:
                DBG("Equal - not implemented yet");
                break;
            }
            DBG("\n");
#if MPI_MASTER_WORKER
            DBG("\tNumber of processes: %d\n", n_processes);
#endif
            DBG("\tNumber of threads per process: %d\n", config.attr_model_eval.numberOfThreads);
            DBG("\tNumber of threads for tree search: %d\n", config.attr_tree_search.numberOfThreads);
#if MPI_MASTER_WORKER
            if (n_processes > 1) {
                DBG("\tImplementation: Parallel\n");
            } else {
                DBG("\tImplementation: Sequential\n");
            }
#endif
        }

        // configure model space
        model_space_t model_space;
        init_range_model_space(&model_space, (unsigned)lower_bound, (unsigned)upper_bound);
        // choose implementation
#if MPI_MASTER_WORKER
        if (n_processes > 1) {
            // mpi master worker
            error = run_master_worker(process_id, MPI_COMM_WORLD, datafile, &config, &model_space, print_progress);
        } else
#endif
        {
            // sequential
            error = run_sequential(datafile, &config, &model_space);
        }
        if (error) {
            ERROR("Execution ended with error code %d\n", error);
        }
        destroy_model_space(&model_space);
    } else {
        error = 1;
        ERROR("Usage: %s (-f|--data) datafile [-b|--opt-freq] [(-l|--lower-bound) incl_index] [(-u|--upper-bound) excl_index] [(-n|--npthreads) number] [(-s|--npthreads-tree) number] [(-r|--rseed) longvalue] [(-c|--config)] [(-p|--progress)] [(-g|--with-gtr)]\n", argv[0]);
    }
#if MPI_MASTER_WORKER
    MPI_Finalize();
#endif
    return error;
}
コード例 #29
0
ファイル: configfile.cpp プロジェクト: uqs/avalon
/*
 * parse - parses the command line.  The caller is responsible for error
 * 		checking.  The return value is any erro that may have ocurred.
 *   ERROR_NONE    - No error.
 *   ERROR_UNKNOWN - An unknown parameter was passed.
 *   ERROR_MISSING - A parameter was needed but missing.
 *   ERROR_EXTRA   - Too many unswitched paremeters.
 * Note: ERROR_EXTRA is used internally to signal the subroutines to
 * 		increment.  These cases do not result in an actual error.
 */
int configfile::parse(int argc, char *argv[])
{
    // For simplicity's sake, the configfile object tracks the name of
    // the program.
    prog_name = argv[0];

    // Now parse each argument.  Config items are scanned using simple
    // rules for command line parameters defined as follows:
    //   A character - The object uses that character
    //   A digit - The object uses the unswitched parameter with that index (starting with 0)
    //   A dash - the object uses the standard long-name format of two
    //			dashes followed by the configuration file name with any
    //			spaces in the name replaced with dashes.
    // One or more of the following can be appended to the string
    //   A dash - The object uses the character or the long-name
    //			convention as above.
    //   An equal sign - For a single character the next parameter will be
    //			used, for a long name anything after the = will be used.
    int err;
    int index = 1;
    int parm_index = 0;

    while (index < argc)
    {
        if (CHAR_DASH == argv[index][0])
        {
            // The first character is a dash, so the parameter must
            // be a switch item.
            if (CHAR_DASH == argv[index][1])
            {
                // Long-name parameter
                err = parse_long(&(argv[index][2]));
                if (ERROR_NONE != err)
                    return err;
            }
            else
            {
                // single character parameter (may be multiple)
                for (int count = 1; 0 != argv[index][count]; ++count)
                {
                    // Parse the character.  We will fail if the character is unknown.
                    if((index + 1) < argc)
                    {
                        err = parse_char(argv[index][count], argv[index + 1]);
                    }
                    else
                    {
                        err = parse_char(argv[index][count], std::string());
                    }
                    if (ERROR_UNKNOWN == err)
                        return err;
                    else if (ERROR_EXTRA == err)
                    {
                        // The next parameter was also read, so skip it.
                        index++;
                        break;
                    }
                }
            }
        }
        else
        {
            // Cache the unescaped parameters
            cmds.push_back(argv[index]);

            // Parse the indexed parameter, if there is one.
            if (parm_index <= 9)
            {
                err = parse_index(parm_index, argv[index]);
                if ((ERROR_NONE != err) && (ERROR_EXTRA != err))
                    return err;
            }
            ++parm_index;
        }

        ++index;
    }

    // Return no error.
    return ERROR_NONE;
}
コード例 #30
0
bool parse_cg_polygon(sk_str *source, sk_cg_geometry *buffer)
{
    if (!source || !buffer)
    {
        return false;
    }

    bool retval = true;
    char delimiter = ' ';

    sk_iterator tokens;
    if (!sk_str_split(&tokens, source, delimiter))
    {
        retval = false;
        goto str_split_fail;
    }

    if (!sk_list_init(&buffer->geometry.polygon.points, NULL))
    {
        retval = false;
        goto list_init_fail;
    }

    char *token;
    sk_str str_token;
    SINT_64 x_coord;
    SINT_64 y_coord;
    while (tokens.has_next(&tokens))
    {
        token = tokens.next(&tokens);

        if (!tokens.has_next(&tokens))
        {
            retval = false;
            goto parse_point_fail;
        }

        sk_str_init(&str_token, token, 8);

        if (!parse_long(&str_token, 0, &x_coord))
        {
            retval = false;
            sk_str_destroy(&str_token);
            goto parse_point_fail;
        }

        sk_str_destroy(&str_token);

        token = tokens.next(&tokens);

        sk_str_init(&str_token, token, 8);

        if (!parse_long(&str_token, 0, &y_coord))
        {
            retval = false;
            sk_str_destroy(&str_token);
            goto parse_point_fail;
        }

        sk_str_destroy(&str_token);

        sk_cg_point *point = ALLOC(*point, 1);
        point->x = x_coord;
        point->y = y_coord;
        sk_list_append(&buffer->geometry.polygon.points, point);
    }

    sk_cg_point *first = sk_list_pop_head(&buffer->geometry.polygon.points);
    sk_cg_point *last = sk_list_pop_tail(&buffer->geometry.polygon.points);
    if (!sk_cg_point_equals(first, last))
    {
        retval = false;
        goto parse_point_fail;
    }
    sk_list_prepend(&buffer->geometry.polygon.points, first);

    buffer->type = POLYGON;

parse_point_fail:

    if (!retval)
    {
        sk_iterator it;
        sk_list_begin(&it, &buffer->geometry.polygon.points);
        while(it.has_next(&it))
        {
            free(it.next(&it));
        }

        sk_list_destroy(&buffer->geometry.polygon.points);
    }
list_init_fail:

    tokens.destroy(&tokens);
str_split_fail:

    return retval;
}