C++ STRNCMP函数代码示例

void test2()
{
    const char* src = "100 120\n"
                      "0 process0 2 10 1 1 2 2\n"
                      "0 process1 2 10 1 1 2 2\n"
                      "0 process2 2 10 1 1 2 2\n"
                      "0 process3 2 10 1 1 2 2\n";

    mm_simulator_t* simulator = mm_simulator_parse(src);

    ASSERT(simulator->physical && simulator->virtual,
           "Must have created physical and virtual memories");
    ASSERT(simulator->physical->size == 100, "");
    ASSERT(simulator->virtual->size == 120, "");
    ASSERT(simulator->process_count == 4, "");

    ASSERT(simulator->processes[0]->t0 == 0, "");
    STRNCMP(simulator->processes[0]->pname, "process0");
    ASSERT(simulator->processes[0]->access_count == 2, "");
    ASSERT(simulator->processes[0]->access[0].position == 1, "");
    ASSERT(simulator->processes[0]->access[0].time == 1, "");

    STRNCMP(simulator->processes[1]->pname, "process1");
    STRNCMP(simulator->processes[2]->pname, "process2");
    STRNCMP(simulator->processes[3]->pname, "process3");

    while (simulator->process_count-- > 0)
        mm_process_destroy(simulator->processes[simulator->process_count]);
    mm_simulator_destroy(simulator);
}

void MemChecker_ParseLineCB(void *pUser, const char *pszKey, int nKeyLen, const char *pszValue, int nValueLen)
{
    MemChecker *pMe = (MemChecker *)pUser;
    char *pszValueCopy = NULL;

    pszValueCopy = MALLOC(nValueLen + 1);
    if (NULL == pszValueCopy) {
        return;
    }
    MEMCPY(pszValueCopy, pszValue, nValueLen);

    if (0 == STRNCMP("ClassID", pszKey, nKeyLen))
    {
        if (STRBEGINS("0x", pszValueCopy)) {
            pMe->m_clsCheckedApp = STRTOUL(pszValueCopy, NULL, 16);
        } else {
            pMe->m_clsCheckedApp = ATOI(pszValueCopy);
        }
    }
    else if (0 == STRNCMP("OutputTo", pszKey, nKeyLen))
    {
        pMe->m_eOutputMode = ATOI(pszValueCopy);
    }

    FREEIF(pszValueCopy);
}

void test3()
{
  const char* msg =
      ":levin.mozilla.org NOTICE Auth :*** Looking up your hostname...\r\n";

  yi_buffer_t* buf = yi_buffer_create(msg, strlen(msg));

  // prefix = levin.mozilla.org
  ASSERT(yi_lex_prefix(buf), "");
  ASSERT(buf->token->type == YI_T_PREFIX_HOSTNAME, "");
  STRNCMP(buf->token->buf, "levin.mozilla.org");

  // textual command
  ASSERT(yi_lex_command(buf), "");
  ASSERT(buf->token->type == YI_T_COMMAND, "");
  STRNCMP(buf->token->buf, "NOTICE");

  // parameter
  ASSERT(yi_lex_param_middle(buf), "");
  ASSERT(buf->token->type == YI_T_PARAM, "");
  STRNCMP(buf->token->buf, "Auth");

  // parameter
  ASSERT(yi_lex_param_trailing(buf), "");
  ASSERT(buf->token->type == YI_T_PARAM, "");
  STRNCMP(buf->token->buf, "*** Looking up your hostname...");

  // crlf
  ASSERT(yi_lex_terminal(buf, "\r\n", 2), "tokenize crlf");
  ASSERT(buf->token->type == YI_T_TERMINAL, "it's a terminal!");

  yi_buffer_destroy(buf);
}

void test2()
{
  const char* msg =
      ":levin.mozilla.org 376 guest :End of message of the day.\r\n";

  yi_buffer_t* buf = yi_buffer_create(msg, strlen(msg));

  // prefix = levin.mozilla.org
  ASSERT(yi_lex_prefix(buf), "");
  ASSERT(buf->token->type == YI_T_PREFIX_HOSTNAME, "");
  STRNCMP(buf->token->buf, "levin.mozilla.org");

  // numeric command
  ASSERT(yi_lex_command(buf), "");
  ASSERT(buf->token->type == YI_T_COMMAND, "");
  STRNCMP(buf->token->buf, "376");

  // parameter
  ASSERT(yi_lex_param_middle(buf), "");
  ASSERT(buf->token->type == YI_T_PARAM, "");
  STRNCMP(buf->token->buf, "guest");

  // parameter
  ASSERT(yi_lex_param_trailing(buf), "");
  ASSERT(buf->token->type == YI_T_PARAM, "");
  STRNCMP(buf->token->buf, "End of message of the day.");

  yi_buffer_destroy(buf);
}

void test5()
{
  const char* msg = ":[email protected] NOTICE guest "
                    ":please choose a different nick.\r\n";

  yi_buffer_t* buf = yi_buffer_create(msg, strlen(msg));

  // nicknamed prefix
  ASSERT(yi_lex_prefix(buf), "");
  ASSERT(buf->token->type == YI_T_PREFIX_NICKNAME, "");
  STRNCMP(buf->token->buf, "[email protected]");

  // textual command
  ASSERT(yi_lex_command(buf), "");
  ASSERT(buf->token->type == YI_T_COMMAND, "");
  STRNCMP(buf->token->buf, "NOTICE");

  // parameter
  ASSERT(yi_lex_param_middle(buf), "");
  ASSERT(buf->token->type == YI_T_PARAM, "");
  STRNCMP(buf->token->buf, "guest");

  // parameter
  ASSERT(yi_lex_param_trailing(buf), "");
  ASSERT(buf->token->type == YI_T_PARAM, "");
  STRNCMP(buf->token->buf, "please choose a different nick.");

  // crlf
  ASSERT(yi_lex_terminal(buf, "\r\n", 2), "tokenize crlf");
  ASSERT(buf->token->type == YI_T_TERMINAL, "it's a terminal!");

  yi_buffer_destroy(buf);
}

/// Like hash_find(), but caller computes "hash".
///
/// @param[in]  key  The key of the looked-for item. Must not be NULL.
/// @param[in]  key_len  Key length.
/// @param[in]  hash  The precomputed hash for the key.
///
/// @return Pointer to the hashitem corresponding to the given key.
///         If not found, then return pointer to the empty item that would be
///         used for that key.
///         WARNING: Returned pointer becomes invalid as soon as the hash table
///                  is changed in any way.
hashitem_T *hash_lookup(hashtab_T *const ht,
                        const char *const key, const size_t key_len,
                        const hash_T hash)
{
#ifdef HT_DEBUG
  hash_count_lookup++;
#endif  // ifdef HT_DEBUG

  // Quickly handle the most common situations:
  // - return if there is no item at all
  // - skip over a removed item
  // - return if the item matches
  hash_T idx = hash & ht->ht_mask;
  hashitem_T *hi = &ht->ht_array[idx];

  if (hi->hi_key == NULL) {
    return hi;
  }

  hashitem_T *freeitem = NULL;
  if (hi->hi_key == HI_KEY_REMOVED) {
    freeitem = hi;
  } else if ((hi->hi_hash == hash)
             && (STRNCMP(hi->hi_key, key, key_len) == 0)
             && hi->hi_key[key_len] == NUL) {
    return hi;
  }

  // Need to search through the table to find the key. The algorithm
  // to step through the table starts with large steps, gradually becoming
  // smaller down to (1/4 table size + 1). This means it goes through all
  // table entries in the end.
  // When we run into a NULL key it's clear that the key isn't there.
  // Return the first available slot found (can be a slot of a removed
  // item).
  for (hash_T perturb = hash;; perturb >>= PERTURB_SHIFT) {
#ifdef HT_DEBUG
    // count a "miss" for hashtab lookup
    hash_count_perturb++;
#endif  // ifdef HT_DEBUG
    idx = 5 * idx + perturb + 1;
    hi = &ht->ht_array[idx & ht->ht_mask];

    if (hi->hi_key == NULL) {
      return freeitem == NULL ? hi : freeitem;
    }

    if ((hi->hi_hash == hash)
        && (hi->hi_key != HI_KEY_REMOVED)
        && (STRNCMP(hi->hi_key, key, key_len) == 0)
        && hi->hi_key[key_len] == NUL) {
      return hi;
    }

    if ((hi->hi_key == HI_KEY_REMOVED) && (freeitem == NULL)) {
      freeitem = hi;
    }
  }
}

/*
 * ":sign define {name} ..." command
 */
    static void
sign_define_cmd(char_u *sign_name, char_u *cmdline)
{
    char_u	*arg;
    char_u	*p = cmdline;
    char_u	*icon = NULL;
    char_u	*text = NULL;
    char_u	*linehl = NULL;
    char_u	*texthl = NULL;
    int failed = FALSE;

    // set values for a defined sign.
    for (;;)
    {
	arg = skipwhite(p);
	if (*arg == NUL)
	    break;
	p = skiptowhite_esc(arg);
	if (STRNCMP(arg, "icon=", 5) == 0)
	{
	    arg += 5;
	    icon = vim_strnsave(arg, (int)(p - arg));
	}
	else if (STRNCMP(arg, "text=", 5) == 0)
	{
	    arg += 5;
	    text = vim_strnsave(arg, (int)(p - arg));
	}
	else if (STRNCMP(arg, "linehl=", 7) == 0)
	{
	    arg += 7;
	    linehl = vim_strnsave(arg, (int)(p - arg));
	}
	else if (STRNCMP(arg, "texthl=", 7) == 0)
	{
	    arg += 7;
	    texthl = vim_strnsave(arg, (int)(p - arg));
	}
	else
	{
	    semsg(_(e_invarg2), arg);
	    failed = TRUE;
	    break;
	}
    }

    if (!failed)
	sign_define_by_name(sign_name, icon, linehl, text, texthl);

    vim_free(icon);
    vim_free(text);
    vim_free(linehl);
    vim_free(texthl);
}

void
acpi_db_unload_acpi_table (
	NATIVE_CHAR             *table_arg,
	NATIVE_CHAR             *instance_arg)
{
	u32                     i;
	acpi_status             status;


	/* Search all tables for the target type */

	for (i = 0; i < NUM_ACPI_TABLES; i++) {
		if (!STRNCMP (table_arg, acpi_gbl_acpi_table_data[i].signature,
				acpi_gbl_acpi_table_data[i].sig_length)) {
			/* Found the table, unload it */

			status = acpi_unload_table (i);
			if (ACPI_SUCCESS (status)) {
				acpi_os_printf ("[%s] unloaded and uninstalled\n", table_arg);
			}
			else {
				acpi_os_printf ("%s, while unloading [%s]\n",
					acpi_format_exception (status), table_arg);
			}

			return;
		}
	}

	acpi_os_printf ("Unknown table type [%s]\n", table_arg);
}

/* get an item from a list with the given name */
static generic_item *GetItemFromList(generic_item * list, const char *name)
{
	generic_item *curr;

	for (curr = list; curr != NULL; curr = curr->next) {
		if ((curr->type == TYPE_BLOCK)
		    && !STRNCMP(curr->item.block.block_name, name, MAXSTRLEN))
			return curr;
		if ((curr->type == TYPE_AFFECT)
		    && !STRNCMP(curr->item.affect.varname, name, MAXSTRLEN))
			return curr;
	}
	/* not found */
	return NULL;

}

/// Check what `name` is:
/// @return NODE_NORMAL: file or directory (or doesn't exist)
///         NODE_WRITABLE: writable device, socket, fifo, etc.
///         NODE_OTHER: non-writable things
int os_nodetype(const char *name)
{
#ifdef WIN32
  // Edge case from Vim os_win32.c:
  // We can't open a file with a name "\\.\con" or "\\.\prn", trying to read
  // from it later will cause Vim to hang. Thus return NODE_WRITABLE here.
  if (STRNCMP(name, "\\\\.\\", 4) == 0) {
    return NODE_WRITABLE;
  }
#endif

  uv_stat_t statbuf;
  if (0 != os_stat(name, &statbuf)) {
    return NODE_NORMAL;  // File doesn't exist.
  }

#ifndef WIN32
  // libuv does not handle BLK and DIR in uv_handle_type.
  //    Related: https://github.com/joyent/libuv/pull/1421
  if (S_ISREG(statbuf.st_mode) || S_ISDIR(statbuf.st_mode)) {
    return NODE_NORMAL;
  }
  if (S_ISBLK(statbuf.st_mode)) {  // block device isn't writable
    return NODE_OTHER;
  }
#endif

  // Vim os_win32.c:mch_nodetype does this (since patch 7.4.015):
  //    if (enc_codepage >= 0 && (int)GetACP() != enc_codepage) {
  //      wn = enc_to_utf16(name, NULL);
  //      hFile = CreatFile(wn, ...)
  // to get a HANDLE. But libuv just calls win32's _get_osfhandle() on the fd we
  // give it. uv_fs_open calls fs__capture_path which does a similar dance and
  // saves us the hassle.

  int nodetype = NODE_WRITABLE;
  int fd = os_open(name, O_RDONLY, 0);
  switch(uv_guess_handle(fd)) {
    case UV_TTY:         // FILE_TYPE_CHAR
      nodetype = NODE_WRITABLE;
      break;
    case UV_FILE:        // FILE_TYPE_DISK
      nodetype = NODE_NORMAL;
      break;
    case UV_NAMED_PIPE:  // not handled explicitly in Vim os_win32.c
    case UV_UDP:         // unix only
    case UV_TCP:         // unix only
    case UV_UNKNOWN_HANDLE:
    default:
#ifdef WIN32
      nodetype = NODE_NORMAL;
#else
      nodetype = NODE_WRITABLE;  // Everything else is writable?
#endif
      break;
  }

  close(fd);
  return nodetype;
}

/*
 * Lookup part of a menu name in the translations.
 * Return a pointer to the translation or NULL if not found.
 */
static char_u *menutrans_lookup(char_u *name, int len)
{
  menutrans_T         *tp = (menutrans_T *)menutrans_ga.ga_data;
  char_u              *dname;

  for (int i = 0; i < menutrans_ga.ga_len; ++i) {
    if (STRNCMP(name, tp[i].from, len) == 0 && tp[i].from[len] == NUL) {
      return tp[i].to;
    }
  }

  /* Now try again while ignoring '&' characters. */
  char c = name[len];
  name[len] = NUL;
  dname = menu_text(name, NULL, NULL);
  name[len] = c;
  if (dname != NULL) {
    for (int i = 0; i < menutrans_ga.ga_len; ++i) {
      if (STRCMP(dname, tp[i].from_noamp) == 0) {
        free(dname);
        return tp[i].to;
      }
    }
    free(dname);
  }

  return NULL;
}

void factor_vm::init_parameters_from_args(vm_parameters *p, int argc, vm_char **argv)
{
	default_parameters(p);
	p->executable_path = argv[0];

	int i = 0;

	for(i = 1; i < argc; i++)
	{
		vm_char *arg = argv[i];
		if(STRCMP(arg,STRING_LITERAL("--")) == 0) break;
		else if(factor_arg(arg,STRING_LITERAL("-datastack=%d"),&p->datastack_size));
		else if(factor_arg(arg,STRING_LITERAL("-retainstack=%d"),&p->retainstack_size));
		else if(factor_arg(arg,STRING_LITERAL("-callstack=%d"),&p->callstack_size));
		else if(factor_arg(arg,STRING_LITERAL("-young=%d"),&p->young_size));
		else if(factor_arg(arg,STRING_LITERAL("-aging=%d"),&p->aging_size));
		else if(factor_arg(arg,STRING_LITERAL("-tenured=%d"),&p->tenured_size));
		else if(factor_arg(arg,STRING_LITERAL("-codeheap=%d"),&p->code_size));
		else if(factor_arg(arg,STRING_LITERAL("-pic=%d"),&p->max_pic_size));
		else if(factor_arg(arg,STRING_LITERAL("-callbacks=%d"),&p->callback_size));
		else if(STRCMP(arg,STRING_LITERAL("-fep")) == 0) p->fep = true;
		else if(STRCMP(arg,STRING_LITERAL("-nosignals")) == 0) p->signals = false;
		else if(STRNCMP(arg,STRING_LITERAL("-i="),3) == 0) p->image_path = arg + 3;
		else if(STRCMP(arg,STRING_LITERAL("-console")) == 0) p->console = true;
	}
}

/*******************************************************************************
 *
 * FUNCTION:    hrt_acpi_scan_memory_for_rsdp
 *
 * PARAMETERS:  Start_address       - Starting pointer for search
 *              Length              - Maximum length to search
 *
 * RETURN:      Pointer to the RSDP if found, otherwise NULL.
 *
 * DESCRIPTION: Search a block of memory for the RSDP signature
 *
 ******************************************************************************/
static __init u8 *
hrt_acpi_scan_memory_for_rsdp(u8 * start_address, u32 length)
{
	u32 offset;
	u8 *mem_rover;

	/* Search from given start addr for the requested length  */

	for (offset = 0, mem_rover = start_address;
	     offset < length;
	     offset += ACPI_RSDP_SCAN_STEP, mem_rover += ACPI_RSDP_SCAN_STEP) {

		/* The signature and checksum must both be correct */

		if (STRNCMP((NATIVE_CHAR *) mem_rover,
			    RSDP_SIG, sizeof (RSDP_SIG) - 1) == 0 &&
		    hrt_acpi_checksum(mem_rover, RSDP_CHECKSUM_LENGTH) == 0) {
			/* If so, we have found the RSDP */

			;
			return (mem_rover);
		}
	}

	/* Searched entire block, no RSDP was found */

	return (NULL);
}

void flash_device_listup(struct flash_listup *t)
{
	const wgChar *str;
	HSQUIRRELVM v = qr_open(NULL);
	SQInteger top = sq_gettop(v);

	if(SQ_FAILED(sqstd_dofile(v, _SC("flashdevice.nut"), SQFalse, SQTrue))){
//		puts("flash device script error");
		qr_close(v);
		return;
	}

	int i;
	const int device_num = flash_device_number_get(v);
	sq_settop(v, top);

	for(i = 0; i < device_num; i++){
		flash_device_name_get(v, i, &str);
		if(STRNCMP(str, _SC("dummy"), 6) != 0){
			t->append(t->obj_cpu, str);
			t->append(t->obj_ppu, str);
		}
		sq_settop(v, top);
	}

	qr_close(v);
	v = NULL;
}

/**
 * \retval 0 if the entry is unique in the list
 * \retval != if there are several items with this name in the list
 */
static int CheckDuplicateEntry(generic_item * list, const char *name)
{
	generic_item *curr;
	unsigned int found = 0;

	for (curr = list; curr != NULL; curr = curr->next) {
		if ((curr->type == TYPE_BLOCK)
		    && !STRNCMP(curr->item.block.block_name, name, MAXSTRLEN))
			found++;
		if ((curr->type == TYPE_AFFECT)
		    && !STRNCMP(curr->item.affect.varname, name, MAXSTRLEN))
			found++;
		if (found > 1)
			break;
	}
	return (found > 1);
}