C++ cgc_strlen函数代码示例

int list_cmd(char *args){
	// todo get page number from strtok
	size_t cmd_len = cgc_strlen(args);
	char * pg_num_txt = args;//\\\strtok(NULL, cmd_len);
	if(pg_num_txt == NULL){
		return CMDBADARG;
	}
	if(buf_is_numeric(pg_num_txt) != 1){
		return CMDBADNUMERIC;
	}

	int pg_num_i = atoi(pg_num_txt);
	if(pg_num_i < 0)
		return CMDNEGNUMERIC;

	return transmit_compound_list_page(pg_num_i);
}

char *strncat ( char *dest, const char *src, size_t n )
{
    size_t dest_len = cgc_strlen(dest);
    size_t i;

    if (dest == NULL || src == NULL)
    {
      return(dest);
    }
    for (i = 0; i < n && src[i] != '\0'; i++)
    {
      dest[dest_len+i] = src[i];
    }
    dest[dest_len+i] = '\0';

    return(dest);
}

compounds_sample_t *sample_compounds(const char *seed, const size_t sample_size){
	if(sample_size > N_FORMULAS-1)
		return NULL;
	unsigned int h = crazy_hash(seed, cgc_strlen(seed), 0xcafeb4b4);

	compounds_sample_t *sample = alloc_sample_st(sample_size);
	// todo check alloc
	if(sample == NULL)
		return NULL;
	for(int i =0; i < sample_size; ++i){
		set_sample_at_idx(sample, i,  (h % (N_FORMULAS-1)));
		
		h = crazy_hash((const char *) &h, sizeof(h), h);
	}

	return sample;
}

int input_matrix(matrix_t *m, char *buf, int buf_size)
{
    if (resize_matrix(m, buf, buf_size) == ERROR)
        return ERROR;

    int num_cells = m->num_rows * m->num_cols;
    int cell_val = 0, retval = 0;
    char *num_str = NULL;

    retval = readline(buf, buf_size);
    if (retval == ERROR || retval == FAIL)
    {
        printf("Bad Input\n");
        return retval;
    }

    int number_count = 1;
    int i, j;

    for (i = 0; i < cgc_strlen(buf); i++)
    {
        if (buf[i] == ' ')
            number_count++;
    }

    if (number_count != num_cells)
    {
        printf("Bad Input\n");
        return FAIL;
    }

    for (i = 0; i < m->num_rows; i++)
    {
        for (j = 0; j < m->num_cols; j++)
        {
            num_str = strsep(&buf, " ");
            if (!num_str)
                return ERROR;

            cell_val = strtol(num_str, NULL, 10);
            m->set_cell(m, i, j, cell_val);
        }
    }

    return SUCCESS;
}

static int addvar(var_t *var, char *name, varenum type) {

    if (!(var->name = calloc(cgc_strlen(name)+1)))
        return ERRNOMEM;

    strcpy(var->name, name);

    var->type = type;
    if (global_nspace.last)
        global_nspace.last->next = var;
    global_nspace.last = var;
    if (!global_nspace.first)
        global_nspace.first = var; 
    var->next = NULL; //just to be safe
    global_nspace.count++;
    return 0;
}

/* 
   help command
 */
int cgc_HelpHandler() {
	ShellCmds *c;
	int len;

	c = cgc_cmds;
	while (c->command) {
		cgc_printf("@s", c->command);
		len = 20-cgc_strlen(c->command);
		while (len-- > 0) {
			cgc_printf(" ");
		}
		cgc_printf("@s\n", c->help);
		c++;
	}

	return(0);
}

message *add_random_message(mail_queue *mq) {
    message *m = calloc(sizeof(message));
    m->sender = pick_address();
    m->recipient = pick_address();
    m->subject = gen_random_string(5, 32);
    m->data = gen_random_string(5,256);
    m->data_length = cgc_strlen(m->data);

    if (mq->root != NULL) {
        message *next = mq->root;
        while (next->next != NULL) {
            next = next->next;
        }
        next->next = m;
    }
    return m;
}

// examine str to determine if it can be converted to a number
// return 0 if yes and 0/positive, 1 if yes and negative, -1 if no.
int is_numeric(const char *str) {
    int sign = 0;

    if (cgc_strlen(str) == 0)
        return -1;

    if (*str == '-') {
        str++;
        sign = 1;
    }

    while (*str != '\0') {
        if (*str < '0' || *str > '9')
            return -1;
        str++;
    }
    return sign;
}

int bloomy_check(bloomy_t *bloomy, const char *buf)
{
  uint8_t bit;
  unsigned int i, n;
  if (bloomy == NULL || bloomy->bits == NULL)
    return -1;
  for (i = 0; i < sizeof(bloomy->hashes) / sizeof(hash_t); ++i)
  {
    if (bloomy->hashes[i])
    {
      n = (bloomy->hashes[i](buf, cgc_strlen(buf)) % bloomy->size);
      bit = (bloomy->bits[n/8] & (1 << (n%8)));
      if (!bit)
        return 0;
    }
  }
  return 1;
}

int init(int rot)
{
  int ret = 0;
  size_t numWords = NUM_WORDS;

  //first allocate enough space for the wordlist
  ret = allocate( sizeof(gSeedWords), 0, (void**)(&gWords));
  if (ret != 0)
  {
    return (ret);
  }

  //now calculate how many bytes we need to store the words themselves
  size_t total = 0;
  int i = 0;
  for (i = 0; i < numWords; i++)
  {
    total += cgc_strlen(gSeedWords[i]);
    total += 1; //for the NULL character
  }
 
  ret = allocate(total, 0, (void**)(&gWordData));
  if (ret != 0)
  {
    return (ret);
  } 

  //now that we have both we can fill in the data  
  size_t temp = 0;
  char* pTemp = gWordData;
  for (i = 0; i < numWords; i++)
  {
    gWords[i] = pTemp;
    pTemp += strrotcpy(pTemp, gSeedWords[i], rot);
    pTemp += 1; //for the NULL character
  }
  
  for ( ; i < (PAGE_SIZE / sizeof(char*)); i++)
  {
    gWords[i] = 0;
  }

  return (0);
}

int getopt(int argc, char **argv, char *optstring, int *opt_index) {
  
  int option = -1;
  if (*opt_index >= argc || !argv[*opt_index]) {
    goto DONE;
  }
  for (int i = 0; i < cgc_strlen(optstring); i++) {
    if (*argv[*opt_index] == optstring[i]) {
      option = optstring[i];
      (*opt_index)++;
      goto DONE;
    }
  }
  (*opt_index)++;
  option = 0;
    
DONE:
  return option;
}

/**
* Destroy the dungeon and free all memory
*
* @param dungeon A pointer to the dungeon structure
*
* @return None
*/
void destroyDungeon(Dungeon* dungeon) {
    size_t len;

    bzero((char *)&dungeon->moveTypes, sizeof(Moves));
    if(dungeon->moveList) {
        len = cgc_strlen(dungeon->moveList);
        bzero(dungeon->moveList, len);
        free(dungeon->moveList);
    }
    dungeon->moveList = NULL;

    Room* nextRoom;
    for(Room* room=dungeon->start; room!=NULL; room=nextRoom) {
        nextRoom = (Room *)room->next;
        destroyRoom(&room->contents);
        free(room);
    }

}

size_t strcat( char *dest, char* src )
{
    size_t length = 0;
    size_t start = 0;

    if ( dest == NULL || src == NULL) {
        goto end;
    }

    start = cgc_strlen( dest );

    for ( ; src[length] != 0x00 ; start++, length++ ) {
        dest[start] = src[length];
    }

    length = start;
end:
    return length;
}

static char *
append_to_path(char *path, const char *toappend)
{
    char *tmp;
    size_t len;

    len = cgc_strlen(path);
    if ((tmp = realloc(path, len + MAX_FILE_NAME_LENGTH + 2)) == NULL) {
        free(path);
        return NULL;
    }
    path = tmp;

    strcat(path, "/");
    strncat(path, toappend, MAX_FILE_NAME_LENGTH);
    path[len + MAX_FILE_NAME_LENGTH + 1] = '\0';

    return path;
}

static cell_t *get_cell(char *cell_id)
{
    char row_str[3];
    char col_str[3];
    int row_idx = 0, col_idx = 0;
    int i, len;

    if (get_rowcol(cell_id, row_str, col_str, '\0') == -1)
        return NULL;

    len = cgc_strlen(row_str);
    for (i = 0; i < len; i++)
        row_idx += ((row_str[i] - 64) * pow(26, len - i - 1));

    --row_idx;
    col_idx = strtol(col_str, NULL, 10);
    return &g_sheet[row_idx][col_idx];

}