自学教程：C++ DIE函数代码示例

StringLinkedList *string_linked_list_init(void){    StringLinkedList *sll = malloc(sizeof(StringLinkedList));    if (sll == NULL) {        DIE("ERROR: Not enough memory to allocate StringLinkedList")    }    sll->head = NULL;    sll->tail = NULL;    sll->len = 0;        return sll;}

static voidparse_version_word(char *word, StringLinkedList *sll){    if (expr == NULL) {        setup_version_regex();    }        int ovecsize = 0;    if (pcre_fullinfo(expr, NULL, PCRE_INFO_CAPTURECOUNT, &ovecsize) != 0) {        DIE("ERROR: Problem calling pcre_fullinfo")    }    ovecsize = (ovecsize + 1) * 3;        int *ovector = calloc(ovecsize, sizeof(int));    if (ovector == NULL) {        DIE("ERROR: Not enough memory to allocate ovector")    }    int offset = 0;    int flags = 0;    char *part;    while (0 < pcre_exec(expr, 0, word, strlen(word), offset, flags, ovector, ovecsize)) {                part = malloc((WORD_MAX_LEN+1) * sizeof(char));        if (part == NULL) {            DIE("ERROR: Not enough memory to allocate word")        }        snprintf(part, WORD_MAX_LEN+1, "%.*s", ovector[1]-ovector[0], word+ovector[0]);        string_linked_list_append(sll, part);                offset = ovector[1];        flags |= PCRE_NOTBOL;    }        free(ovector);}

/*	Compute reduced heap size by reserving area and rounding down to	nearest page.*/doublecomputeReserve(double rate, int phases){	assert(rate > 1.0);	if (phases == 0)	/* not concurrent */		return 0.0;	else if (phases == 1) /* concurrent */		return rate / (rate + 1.0);	else if (phases == 2) /* concurrent - non-committing, committing */		return (rate + 1.0) / (rate * rate + rate + 1.0);	DIE("invalid phases");	return 0.0;	/* NOTREACHED */}

int WaitChild(pid_t pid, const char *name) {  int err, status;  do {    err = waitpid(pid, &status, 0);  } while (err == -1 && errno == EINTR);  if (err == -1) {    DIE("wait on %s (pid %d) failed/n", name, pid);  }  return status;}

void add_to_common_env(char *key, char *value){#ifndef EXCLUDE_CGI    common_cgi_env = realloc(common_cgi_env, (common_cgi_env_count + 2) * (sizeof(char *)));    if (common_cgi_env== NULL) {        DIE("Unable to allocate memory for common CGI environment variable.");    }    common_cgi_env[common_cgi_env_count] = env_gen_extra(key,value, 0);    if (common_cgi_env[common_cgi_env_count] == NULL) {        /* errors already reported */        DIE("memory allocation failure in add_to_common_env");    }    common_cgi_env[++common_cgi_env_count] = NULL;    /* I find it hard to believe that somebody would actually     * make 90+ *common* CGI variables, but it's always better     * to be safe.     */    if (common_cgi_env_count > CGI_ENV_MAX) {        DIE("far too many common CGI environment variables added.");    }#endif // !EXCLUDE_CGI}

static void loadRom(){	const char * file = S9xGetFilename(FILE_ROM);	printf("ROM: %s/n", file);	if (!Memory.LoadROM(file))		DIE("Loading ROM failed");		file = S9xGetFilename(FILE_SRAM);	printf("SRAM: %s/n", file);	Memory.LoadSRAM(file); }

Window::Window(Game* parent){  width = height = 600;  game = parent;  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  windowHandle = glfwCreateWindow(width, height, "Grass", NULL, NULL);  glfwSetWindowPos(windowHandle,800,30);  if (!windowHandle)    DIE("Failed to create window");  glfwMakeContextCurrent(windowHandle);}

int recv_c(int socket, byte *recvbuf, int bufsize) {    LOG_DEBUG(TAG_CMD, "Receiving command");    int bytes_total = 0;    int bytes_received = 0;    int bytes_missing = CMD_HEADER_LEN;    uint16_t pl_len = 0;    // Receive header    while (bytes_missing > 0) {        bytes_received = recv(socket, recvbuf+bytes_total, bytes_missing, 0);        if (bytes_received == 0) {            return 0;        } else if (bytes_total > bufsize) {            DIE(TAG_CMD, "Recvbuf overflow");        }        bytes_total += bytes_received;        bytes_missing -= bytes_received;    }    // Check length of the packet and receive more data if needed    memcpy(&pl_len, recvbuf+CMD_PL_LEN_OFFSET, sizeof(uint16_t));    pl_len = ntohs(pl_len);    bytes_received = 0;    bytes_missing = pl_len;    while (bytes_missing > 0) {        bytes_received = recv(socket, recvbuf+bytes_total, bytes_missing, 0);        if (bytes_received == 0) {            LOG_WARN(TAG_CMD, "GUI disconnected");            return 0;        } else if (bytes_total > bufsize) {            DIE(TAG_CMD, "Recvbuf overflow");        }        bytes_total += bytes_received;        bytes_missing -= bytes_received;    }        LOG_DEBUG(TAG_CMD, "Received %d bytes", bytes_total);    return bytes_total;}

static void close_files(void){	size_t n_files = sizeof(files) / sizeof(files[0]);	size_t i;	int rc;	for (i = 0; i < n_files; i++) {		rc = close(fds[i]);		DIE(rc < 0, "close");	}	free(fds);}

/* based on show_diff_time from eachfile.c */void show_time(FILE *out, char T, time_t val){    char	buf[ELC_TIMEBUFSIZ];    putc(T, out);    putc('(', out);    if (! strftime(buf, ELC_TIMEBUFSIZ, "%Y%m%d-%H%M%S", localtime(&val)) )      DIE("strftime");    fputs(buf, out);    fputs(") ", out);}

	static voidflytec_pbrtr(flytec_t *flytec, track_t *track, void (*callback)(void *, const char *), void *data){	char buf[9];	if (snprintf(buf, sizeof buf, "PBRTR,%02d", track->index) != 8)		DIE("sprintf", 0);	flytec_puts_nmea(flytec, buf);	flytec_expectc(flytec, XOFF);	char line[1024];	while (flytec_gets(flytec, line, sizeof line))		callback(data, line);	flytec_expectc(flytec, XON);}

	static voidflytec_puts_nmea(flytec_t *flytec, char *s){	int checksum = 0;	char *p;	for (p = s; *p; ++p)		checksum ^= (unsigned char) *p;	int len = strlen(s) + 7;	char *buf = xmalloc(len);	memset(buf, 0, len);	if (snprintf(buf, len, "$%s*%02X/r/n", s, checksum) != len - 1)		DIE("snprintf", 0);	if (flytec->logfile)		fprintf(flytec->logfile, "> %s", buf);	int rc;	do {		rc = write(flytec->fd, buf, len);	} while (rc == -1 && errno == EINTR);	if (rc == -1)		DIE("write", errno);	free(buf);}

static void create_iocp_accept(void){	BOOL bRet;	memset(&ac, 0, sizeof(ac));	/* Create simple socket for acceptance */	ac.sockfd = socket(PF_INET, SOCK_STREAM, 0);	DIE(ac.sockfd == INVALID_SOCKET, "socket");	/* Launch overlapped connection accept through AcceptEx. */	bRet = AcceptEx(			listenfd,			ac.sockfd,			ac.buffer,			0,			128,			128,			&ac.len,			&ac.ov);	DIE(bRet == FALSE && WSAGetLastError() != ERROR_IO_PENDING, "AcceptEx");}

// PDO error handler for the statement context.bool pdo_sqlsrv_handle_stmt_error( sqlsrv_context& ctx, unsigned int sqlsrv_error_code, bool warning TSRMLS_DC,                                   va_list* print_args ){    pdo_stmt_t* pdo_stmt = reinterpret_cast<pdo_stmt_t*>( ctx.driver());    SQLSRV_ASSERT( pdo_stmt != NULL && pdo_stmt->dbh != NULL, "pdo_sqlsrv_handle_stmt_error: Null statement or dbh passed" );    sqlsrv_error_auto_ptr error;    if( sqlsrv_error_code != SQLSRV_ERROR_ODBC ) {        core_sqlsrv_format_driver_error( ctx, get_error_message( sqlsrv_error_code ), error, SEV_ERROR TSRMLS_CC, print_args );    }    else {        bool err = core_sqlsrv_get_odbc_error( ctx, 1, error, SEV_ERROR TSRMLS_CC );        SQLSRV_ASSERT( err == true, "No ODBC error was found" );    }    SQLSRV_STATIC_ASSERT( sizeof( error->sqlstate ) <= sizeof( pdo_stmt->error_code ));    strcpy_s( pdo_stmt->error_code, sizeof( pdo_stmt->error_code ), reinterpret_cast<const char*>( error->sqlstate ));    switch( pdo_stmt->dbh->error_mode ) {        case PDO_ERRMODE_EXCEPTION:            if( !warning ) {                pdo_sqlsrv_throw_exception( error TSRMLS_CC );            }            ctx.set_last_error( error );            break;        case PDO_ERRMODE_WARNING:            if( !warning ) {                unsigned int msg_len = strlen( reinterpret_cast<const char*>( error->native_message )) + SQL_SQLSTATE_BUFSIZE                     + MAX_DIGITS + 1;                sqlsrv_malloc_auto_ptr<char> msg;                msg = static_cast<char*>( sqlsrv_malloc( msg_len ));                core_sqlsrv_format_message( msg, msg_len, WARNING_TEMPLATE, error->sqlstate, error->native_code,                                             error->native_message );                php_error( E_WARNING, msg );                sqlsrv_free( msg );            }            ctx.set_last_error( error );            break;        case PDO_ERRMODE_SILENT:            ctx.set_last_error( error );            break;        default:            DIE( "Unknown error mode. %1!d!", pdo_stmt->dbh->error_mode );            break;    }    // return error ignored = true for warnings.    return ( warning ? true : false );}

void print(elem *hashtable, int size, char *file_name){	int i;	FILE *fd;	if(file_name != NULL)	{		fd = fopen(file_name, "a");		DIE(fd == NULL, "[print] Error opening file.");	}	for(i = 0; i < size; i++)	{		if(hashtable[i].next != NULL)		{			elem *temp = hashtable[i].next;						if(file_name != NULL)			{				while(temp != NULL)				{					if(temp->next == NULL)						fprintf(fd, "%s", temp->value);				/* Print without the last space */					else						fprintf(fd, "%s ", temp->value);					temp = temp->next;				}			}else			{				while(temp != NULL)				{					if(temp->next == NULL)						printf("%s", temp->value);					else						printf("%s ", temp->value);					temp = temp->next;				}			}			if(file_name != NULL)				fprintf(fd, "/n");			else				printf("/n");		}	}	if(file_name != NULL)		fclose(fd);}

void CNPC::DoWCMilitiaAI() {   if (DIE(1000) <= 4) {	switch (this->GetVnum()) {	   case 13003:		this->AddCommand("emote works on his backstab.");		break;	   case 13005:		this->AddCommand("emote takes a shot at a target and hits it's mark.");		this->AddCommand("smile");		break;	   case 13006:		this->AddCommand("emote takes a shot at a target and misses wildly.");		this->AddCommand("frown");		break;	   case 13007:		this->AddCommand("emote works hard on his next invention, scribbling on a piece of paper.");		break;	   case 13009:		switch (DIE(3)) {		   case 1:			this->AddCommand("emote sits and eats quietly.");			break;		   case 2:			this->AddCommand("say Man, working out really builds up the appetite.");			break;		   case 3:			this->AddCommand("say I liked Mom's cooking much better.");			break;		}		break;	   case 13002:		this->AddCommand("emote sings... I wanna make love to you woman... I wanna lay you down by the fire..");		break;	   default:		break;	}   }}

mem_tmy_mmap(int size, int prot){	caddr_t start = NULL;	static int fd = -1;	int flags;	mem_t mapped;#ifdef sparc	{		if (fd == -1)			if ((fd = open("/dev/zero", O_RDWR)) == -1) {				perror("/dev/zero");				DIE("out of memory");			}		flags = MAP_PRIVATE;	}#else	flags = MAP_ANONYMOUS;#endif#ifdef sparc	/*		We'd like to use on-demand allocation if the OS supports it.		Currently, MAP_NORESERVE is not POSIX.  If other OSs do not		support it, then we should think about implementing a scheme		where Heap_t structures are reallocated to allow for growth.	*/	flags |= MAP_NORESERVE;#endif	mapped = (mem_t) mmap(start, size, prot, flags, fd, 0);	if (mapped == (mem_t) -1) {		fprintf(stderr,"mmap %d failed: %s/n", size, strerror(errno));		DIE("out of memory");	}	if (diag)		fprintf(stderr,"mmap %d succeeded with mapped = %lx, prot = %d/n",			size, (long)mapped, prot);	return mapped;}

intcmd_crop(mpd_unused int argc, mpd_unused char **argv, struct mpd_connection *conn){	struct mpd_status *status = getStatus( conn );	int length = mpd_status_get_queue_length(status) - 1;	if (length < 0) {		mpd_status_free(status);		DIE( "A playlist longer than 1 song in length is required to crop./n" );	} else if (mpd_status_get_state(status) == MPD_STATE_PLAY ||		   mpd_status_get_state(status) == MPD_STATE_PAUSE) {		if (!mpd_command_list_begin(conn, false))			printErrorAndExit(conn);		while( length >= 0 )		{			if (length != mpd_status_get_song_pos(status)) {				mpd_send_delete(conn, length);			}			length--;		}		mpd_status_free(status);		if (!mpd_command_list_end(conn) || !mpd_response_finish(conn))			printErrorAndExit(conn);		return ( 0 );	} else {		mpd_status_free(status);		DIE( "You need to be playing to crop the playlist/n" );	}}

intcmd_crop(mpd_unused int argc, mpd_unused char **argv, mpd_Connection *conn){	mpd_Status *status = getStatus( conn );	int length = ( status->playlistLength - 1 );	if( status->playlistLength == 0 ) {		mpd_freeStatus(status);		DIE( "You have to have a playlist longer than 1 song in length to crop" );	} else if( status->state == 3 || status->state == 2 ) { /* If playing or paused */		mpd_sendCommandListBegin( conn );		printErrorAndExit( conn );		while( length >= 0 )		{			if( length != status->song )			{				mpd_sendDeleteCommand( conn, length );				printErrorAndExit( conn );			}			length--;		}		mpd_sendCommandListEnd( conn );		my_finishCommand( conn );		mpd_freeStatus( status );		return ( 0 );	} else {		mpd_freeStatus(status);		DIE( "You need to be playing to crop the playlist/n" );	}}

static void handle_new_connection(OVERLAPPED *ovp){	struct connection *conn;	char abuffer[64];	HANDLE hRet;	int rc;	rc = setsockopt(			ac.sockfd,			SOL_SOCKET,			SO_UPDATE_ACCEPT_CONTEXT,			(char *) &listenfd,			sizeof(listenfd)		  );	DIE(rc < 0, "setsockopt");	rc = get_peer_address(ac.sockfd, abuffer, 64);	if (rc < 0) {		ERR("get_peer_address");		return;	}	dlog(LOG_DEBUG, "Accepted connection from %s/n", abuffer);	/* Instantiate new connection handler. */	conn = connection_create(ac.sockfd);	/* Add socket to IoCompletionPort. */	hRet = w_iocp_add_key(iocp, (HANDLE) conn->sockfd, (ULONG_PTR) conn);	DIE(hRet != iocp, "w_iocp_add_key");	/* Schedule receive operation. */	connection_schedule_socket_receive(conn);	/* Use AcceptEx to schedule new connection acceptance. */	create_iocp_accept();}

int main(int argc, char **argv) {	FILE *in ;	MATRIX m ;	int j, i ;	if(argc != 2 ) 		DIE("Missing parameter", 1) ;	in = fopen(argv[1], "r") ;	if(!in)		DIE("Could not open file", 2) ;	read_file(in, &m) ;	fclose(in) ;	print_matrix(&m) ;	printf("========/n") ;	matrix_to_entity(&m)  ;	print_matrix(&m) ;	free_matrix(&m) ;		return 0 ;}

LPVOID MapFile(HANDLE hFile, DWORD size) {	HANDLE hFileMap;	LPVOID p;	hFileMap = CreateFileMapping(			hFile,			NULL,			PAGE_READWRITE,			0,			size,			NULL);	DIE(hFileMap == NULL, "CreateFileMapping");	p = MapViewOfFile(			hFileMap,			FILE_MAP_ALL_ACCESS,			0,			0,			0);	DIE(p == NULL, "MapViewOfFile");	return p;}

static voiddo_block(const void *in, size_t len, size_t buf_len, size_t offset,         size_t fp_len, int action, int options) {  switch (action) {  case BMZ_A_PACK:    do_pack(in, len, buf_len, offset, fp_len, options);    break;  case BMZ_A_UNPACK:    do_unpack(in, len, buf_len);    break;  default:    DIE("unknown action: %d", action);  }}

intcmd_disable(mpd_unused int argc, char **argv, mpd_Connection *conn){	int arg;        if( ! parse_int( argv[0], &arg ) || arg <= 0 ) {		DIE( "Not a positive integer/n" );	} else {		mpd_sendDisableOutputCommand( conn, ( arg - 1 ) );	}	mpd_finishCommand( conn );	return cmd_outputs(0, NULL, conn);}

int cmd_list ( int argc, char ** argv, mpd_Connection * conn ){	Constraint *constraints;	int numconstraints = 0;	int type;	int i;	char *tag;	type = get_search_type(argv[0]);	if (type < 0)		return -1;	argc -= 1;	argv += 1;	if (argc > 0) {		if (argc % 2 != 0) {			DIE("arguments must be a tag type and "			    "optional pairs of search types and queries/n");		}		numconstraints = get_constraints(argc, argv, &constraints);		if (numconstraints < 0)			return -1;	}	mpd_startFieldSearch(conn, type);	if (argc > 0) {		for (i = 0; i < numconstraints; i++) {			mpd_addConstraintSearch(conn, constraints[i].type,						charset_to_utf8(constraints[i].query));		}		free(constraints);	}	mpd_commitSearch(conn);	printErrorAndExit(conn);	while ((tag = mpd_getNextTag(conn, type))) {		printErrorAndExit(conn);		printf("%s/n", charset_from_utf8(tag));		free(tag);	}	my_finishCommand(conn);	return 0;}

int getIntegerParameter(const char* paramName, int defaultValue, int allowDefault){	char paramValue[VALUE_LENGTH];	char defaultString[VALUE_LENGTH];	sprintf(defaultString, "%d", defaultValue);	int error = getMaskedParameter(paramValue, paramName, defaultString, allowDefault);	int result = atoi(paramValue);	if(result == 0 && strcmp(paramValue, "0") != 0){		DIE("ERROR: Wrong value of %s in a configuration file ('%s'). Should be integer.", paramName, paramValue);	}	if(error != 0){		return 0;	}	return result;}

voidmore_begin(void){  static struct termios tty;  tty = stored_tty;  tty.c_lflag &= (~ECHO);  tty.c_lflag &= (~ICANON);  if (tcsetattr (0, TCSANOW, &tty) < 0)    DIE("tcsetattr");  more_active = 1;}

static void start_task_monitor(void){	int rc;	setup_cpumask();	DEBUG("Starting task life cycle monitor on CPUs %s/n", nl_cpumask);	rc = send_cmd(nl_fd, nl_id,		      getpid(),		      TASKSTATS_CMD_GET, TASKSTATS_CMD_ATTR_REGISTER_CPUMASK,		      nl_cpumask, strlen(nl_cpumask) + 1);	if (rc < 0)		DIE("send cmd failed with error %d/n", rc);}

static void sendto_ok(void) {	int sockfd;	struct sockaddr_sw local_addr;	struct sockaddr_sw remote_addr;	ssize_t bytes_sent;	char buffer[BUFSIZ];	int rc;	fill_sockaddr_sw(&local_addr, &remote_addr, "127.0.0.1", "myHash", "127.0.0.1");	sockfd = sw_socket(PF_INET, SOCK_DGRAM, IPPROTO_SWIFT);	DIE(sockfd < 0, "sw_socket");	rc = sw_bind(sockfd, (struct sockaddr *) &local_addr, sizeof(local_addr));	DIE(rc < 0, "sw_bind");	bytes_sent = sw_sendto(sockfd, buffer, BUFSIZ, 0, (struct sockaddr *) &remote_addr, sizeof(remote_addr));		perror("sw_sendto");	test( bytes_sent >= 0 );}

intcmd_volume(int argc, char **argv, struct mpd_connection *conn){	struct int_value_change ch;	if (argc == 1) {		if (!parse_int_value_change(argv[0], &ch))			DIE("/"%s/" is not an integer/n", argv[0]);	} else {		struct mpd_status *status = getStatus(conn);		if (mpd_status_get_volume(status) >= 0)			printf("volume:%3i%c/n",			       mpd_status_get_volume(status), '%');		else			printf("volume: n/a/n");		mpd_status_free(status);		return 0;	}	if (ch.is_relative) {#if LIBMPDCLIENT_CHECK_VERSION(2,9,0)		if (mpd_connection_cmp_server_version(conn, 0, 18, 0) >= 0) {			/* MPD 0.18 knows the "volume" command for			   relative changes */			if (!mpd_run_change_volume(conn, ch.value))				printErrorAndExit(conn);			return 1;		}#endif		struct mpd_status *status = getStatus(conn);		int old_volume = mpd_status_get_volume(status);		mpd_status_free(status);		ch.value += old_volume;		if (ch.value < 0)			ch.value = 0;		else if (ch.value > 100)			ch.value = 100;		if (ch.value == old_volume)			return 1;	}	if (!mpd_run_set_volume(conn, ch.value))		printErrorAndExit(conn);	return 1;}