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

int zkServer::isLeader() {    int ret = 0;    int flag = 1;    if(NULL == zkhandle)    {        ERROR_PRINT(" zkhandle is NULL ", "");        return -1;    }    struct String_vector strings;    DEBUG_PRINT("root %s server_name %s count %u", root.c_str(), server_name.c_str(), strings.count);    ret = zoo_get_children(zkhandle, (root+server_name).c_str(), 0, &strings);    if (ret) {        ERROR_PRINT("Error %d for %s", ret, "get_children");        return -1;    }    int i;    for ( i=0; i<strings.count; i++ ) {        DEBUG_PRINT("node_name %s string[%d].data %s", node_name.c_str(), i, strings.data[i]);        if ( strcmp(node_name.c_str(), strings.data[i])>0 ) { /* 如果我自己不是最小的节点 */            flag = 0;            break;        }    }    deallocate_String_vector(&strings);    return flag;}

hid_return hid_os_force_claim(HIDInterface* const hidif, int const interface,    HIDInterfaceMatcher const* const matcher, unsigned short retries UNUSED){  if (!hidif) {    ERROR_PRINT("cannot open NULL HIDInterface.");    return HID_RET_INVALID_PARAMETER;  }  if (!hid_is_opened(hidif)) {    ERROR_PRINT("cannot force claim interface of unopened HIDInterface.");    return HID_RET_DEVICE_ALREADY_OPENED;  }  if (!matcher) {    ERROR_PRINT("cannot match against NULL HIDInterfaceMatcher.");    return HID_RET_INVALID_PARAMETER;  }  WARNING_PRINT("code not tested on the Darwin platform!");  TRACE_PRINT("claiming USB device %s...", hidif->id);#if 1  if (usb_claim_interface(hidif->dev_handle, interface) < 0) {    WARNING_PRINT("failed to claim USB device %s...", hidif->id);    /* return HID_RET_FAIL_CLAIM_IFACE; */  }#endif  return HID_RET_SUCCESS;}

int main ( int argc, const char*argv[] ){    bool bret;    CSemaphoreMutex sem;    int sec = 3;    int id;	signal(SIGINT,Sighandler);	signal(SIGTERM,Sighandler);    if ( argc < 3 )    {        ERROR_PRINT ( "%s filename key [sec]/n", argv[0] );        exit ( 3 );    }    if ( argc >= 4 )    {        sec = atoi ( argv[3] );    }    id = atoi ( argv[2] );    bret = sem.Create ( argv[1], id );    if ( !bret )    {        ERROR_PRINT ( "can not create %s:%d/n", argv[1], id );		return -2;			    }	DEBUG_PRINT("create %s:%d sem/n",argv[1],id);    CliSem ( sem, sec );	DEBUG_PRINT("/n");	sem.Destroy();    return 0;}

static int SMT113J_SPI_probe(struct platform_device *pdev){	int 	ret;	struct	device *SMT113J_SPI_dev;	DEBUG_PRINT("SMT113J_SPI_probe : Start!"); 	ret = register_chrdev ( NODE_MAJOR, NODE_PATHNAME, &SMT113J_SPI_ctl_fops );		if ( 0 > ret ) 	{		ERROR_PRINT("SMT113J_SPI_probe : register_chrdev failed : ret = %d!", 					ret );		return ( -EFAULT );	}		SMT113J_SPI_class = class_create(THIS_MODULE, NODE_PATHNAME);	if (IS_ERR(SMT113J_SPI_class)) 	{		ERROR_PRINT("SMT113J_SPI_probe : class_create failed : ret = %d!", 					ret );		unregister_chrdev(NODE_MAJOR, NODE_PATHNAME);		class_destroy(SMT113J_SPI_class);		return ( -EFAULT );	}	SMT113J_SPI_dev = device_create ( SMT113J_SPI_class, 									  NULL,									  MKDEV(NODE_MAJOR, NODE_MINOR),									  NULL, 									  NODE_PATHNAME);					if (IS_ERR(SMT113J_SPI_dev)) 	{		ERROR_PRINT("SMT113J_SPI_probe : device_create failed : ret = %d!", 					ret );		unregister_chrdev(NODE_MAJOR, NODE_PATHNAME);		class_destroy(SMT113J_SPI_class);		return ( -EFAULT );	}	ret = spi_register_driver ( &smt113j_spi_driver );		if (ret < 0) 	{		ERROR_PRINT(			"SMT113J_SPI_probe : spi_register_driver failed : ret = %d!",			ret );		return ( -EBUSY );	}	smt113j_spi_thread_Init();		DEBUG_PRINT("SMT113J_SPI_probe : End!");		return 0;}

bool Game::init() {    if( SDL_Init( SDL_INIT_EVERYTHING ) != 0 ) {        ERROR_PRINT( SDL_GetError() );        return false;    }    SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 3 );    SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 3 );    SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );    m_window = SDL_CreateWindow( "Brick Breaker",                                 SDL_WINDOWPOS_CENTERED,                                 SDL_WINDOWPOS_CENTERED,                                 wWindow,                                 hWindow,                                 SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL                                );    if( !m_window ) {        ERROR_PRINT( SDL_GetError() );        return false;    }    if( !SDL_GL_CreateContext( m_window ) ) {        ERROR_PRINT( "Failed creating OpenGL context" );        return false;    }    glewExperimental = GL_TRUE;    GLenum glewError = glewInit();    if( glewError != GL_NO_ERROR ) {        ERROR_PRINT( "Glew init failed" );        return false;    }//    glViewport( 0, 0, wWindow, hWindow );//    if( SDL_GL_SetSwapInterval( -1 ) < 0 ) {//        if( SDL_GL_SetSwapInterval( 1 ) < 0 ) {//            ERROR_PRINT( "Failed to enable VSync" );//        }//    }    if( !m_renderer.init() ) {        ERROR_PRINT( "Renderer failed to init" );        return false;    }    m_runClock.restart();    m_secondsTimer.setLimit( 1.0 );    m_frameCounter = 0;    m_gameState = new LevelState( *this );    m_gameState->init();    return true;}

static intaccess_client_startDaemon(int cpu_id){    /* Check the function of the daemon here */    int res = 0;    char* filepath;    char *newargv[] = { NULL };    char *newenv[] = { NULL };    char *safeexeprog = TOSTRING(ACCESSDAEMON);    char exeprog[1024];    struct sockaddr_un address;    size_t address_length;    int  ret;    pid_t pid;    int timeout = 1000;    int socket_fd = -1;    int print_once = 0;    if (config.daemonPath != NULL)    {        strcpy(exeprog, config.daemonPath);    }    else    {        strcpy(exeprog, safeexeprog);    }    if (access(exeprog, X_OK))    {        ERROR_PRINT(Failed to find the daemon '%s'/n, exeprog);        exit(EXIT_FAILURE);    }    DEBUG_PRINT(DEBUGLEV_INFO, Starting daemon %s, exeprog);    pid = fork();    if (pid == 0)    {        if (cpu_id >= 0)        {            cpu_set_t cpuset;            CPU_ZERO(&cpuset);            CPU_SET(cpu_id, &cpuset);            sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);        }        ret = execve (exeprog, newargv, newenv);        if (ret < 0)        {            //ERRNO_PRINT;            ERROR_PRINT(Failed to execute the daemon '%s'/n, exeprog);            exit(EXIT_FAILURE);        }    }    else if (pid < 0)    {        ERROR_PRINT(Failed to fork access daemon for CPU %d, cpu_id);        return pid;    }

static void robot_open_connection(robot_t *self){    int nb;	int r;	struct sockaddr_in address;	memset(&address, 0, sizeof(address));	address.sin_family = AF_INET;	address.sin_port  = htons(g_config.port);	address.sin_addr.s_addr = inet_addr(g_config.ip);    self->socketfd = socket(AF_INET, SOCK_STREAM, 0);    if(self->socketfd == -1)    {        ERROR_PRINT("robot [%d] socket errno [%d], %s.", self->id, errno, strerror(errno));		exit(1);    }        if(setsockopt(self->socketfd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)) == -1)	{	        ERROR_PRINT("robot [%d] setsockopt errno[%d], %s.", self->id, errno, strerror(errno));		exit(1);	}    if(setsockopt(self->socketfd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)) == -1)	{        ERROR_PRINT("robot [%d] setsockopt errno[%d], %s.", self->id, errno, strerror(errno));		exit(1);	}	    nb = 1;	if(ioctl(self->socketfd, FIONBIO, &nb) == -1)	{        ERROR_PRINT("robot [%d] ioctl errno[%d], %s.", self->id, errno, strerror(errno));		exit(1);	}	for(;;)	{	    r = connect(self->socketfd, (struct sockaddr *)&address, sizeof(address));		if(r == 0)		{			break;		}		if(errno == EINPROGRESS)		{		    break;		}		if((errno != EINTR) && (errno != EAGAIN) &&(errno != EWOULDBLOCK))		{			ERROR_PRINT("robot [%d] connect errno [%d], %s", self->id, errno, strerror(errno));			exit(1);		}		usleep(IDLE_TIME_US);	}}

static int SMT113J_SPI_open(struct inode *inode, struct file *filp){	int ret = 0;	unsigned int majorno = 0, 				 minorno = 0;	unsigned char *devarea = NULL;	DEBUG_PRINT("SMT113J_SPI_open << Start >>");	majorno = imajor(filp->f_dentry->d_inode);	minorno = iminor(filp->f_dentry->d_inode);	if (( majorno != NODE_MAJOR ) || 		( minorno != NODE_MINOR )) 	{		ERROR_PRINT ("SMT113J_SPI_open Error : << No MAJOR(%d) or No MINOR(%d)",					 majorno,					 minorno );		return ( -ENODEV );	}		/*** Private Data Area MALLOC Stataus Check ***/	if ( NULL != ( devarea = (unsigned char *)filp->private_data ))	{		ERROR_PRINT(			"SMT113J_SPI_open Error : << Used Private Data Area[0x%08x] >>", 			(int)devarea );		return ( -ENODEV );	}		/*** Private Data Area Alloc ***/	if ( NULL == ( devarea = (unsigned char *)kmalloc ( 								sizeof(smt113j_ioctl_data), GFP_KERNEL ))) 	{		ERROR_PRINT(			"SMT113J_SPI_open Error : << Used Private Data Area Alloc Error");		return ( -ENOMEM ) ;	}	memset ( devarea, 0,  sizeof ( smt113j_ioctl_data ));	filp->private_data = (void *)devarea;		/*** buffer clear ***/	memset ( rx_pkt_buffer, 0, MAX_BUFFER_PKT * PAKCET_SIZE );	pwrite = 0;	pread  = 0;		spi_open_cnt++;		DEBUG_PRINT("SMT113J_SPI_open << End >>");		return ( ret );}

int prefetcher_init(void){    BUG();    L4_KDB_Enter("Implement me");#if 0    uint64_t source, target;    FILE *pdata;    PEntry *entry;    dprintk(0,"Initializing prefetch cache ");    if( (prefetch_cache = lhmap_create(2097169)) == NULL)	return -1;    /* load prefetch data from file into cache */    if( (pdata=fopen("prefetch.data", "rb")) == NULL)    {	ERROR_PRINT("cannot open prefetch.data");	return -1;    }    while(fscanf(pdata, "%llu -> %llu/n", &source, &target ) != EOF)    {	if(lhmap_lookup(prefetch_cache, source) != NULL)	{	    ERROR_PRINT("invalid prefetcher data");	    return -1;	}	if( (entry = (PEntry*)qemu_malloc(sizeof(PEntry))) == NULL)	{	    ERROR_PRINT("malloc failed");	    return -1;	}	entry->next = target;		if( lhmap_insert(prefetch_cache, source, entry))	{	    ERROR_PRINT("insert failed");	    return -1;	}    }    fclose(pdata);#endif    dprintk(0,"done./n");    return 0;}

void asciiBoxes_addBox(BoxContainer* container, int line, int column, bstring label){    if ( line >= container->numLines )    {        ERROR_PRINT(line id %d too large,line);    }    if ( column >= container->numColumns )    {        ERROR_PRINT(column id %d too large,column);    }    container->boxes[line][column].width = 1;    container->boxes[line][column].label = bstrcpy(label);}

void serializeState(State *state, char *fileName, int append) {	FILE *fp = NULL;	if (append) {		fp = fopen(fileName, "a");		fprintf(fp, "------------------------------/n");	} else {		fp = fopen(fileName, "w");	}	if (fp == NULL) {		ERROR_PRINT("Couldn't find file: %s", fileName);		exit(1);	}	for (int i = BOARD_DIM-1; i >= 0; i--) {		char line[BOARD_DIM+1];		for (int j = 0; j < BOARD_DIM; j++) {			int point = i*BOARD_DIM+j;			switch (state->board[point]) {				case STATE_WHITE:					line[j] = 'W';					break;				case STATE_BLACK:					line[j] = 'B';					break;				case STATE_EMPTY:					line[j] = '-';					break;				default:					ERROR_PRINT("Unknown character in serializing: %d at point %d", state->board[point], point);					exit(1);			}		}		line[BOARD_DIM] = '/0';		fprintf(fp, "%s/n", line);	}	fprintf(fp, "%c/n", state->turn == STATE_WHITE ? 'W' : 'B');	fprintf(fp, "%d/n", state->whitePrisoners);	fprintf(fp, "%d/n", state->blackPrisoners);	fprintf(fp, "%d/n", state->koPoint);	fprintf(fp, "%d/n", state->blackPassed);	fclose(fp);}

hid_return hid_prepare_interface(HIDInterface* const hidif){  hid_return ret;  if (!hid_is_opened(hidif)) {    ERROR_PRINT("cannot prepare unopened HIDinterface.");    return HID_RET_DEVICE_NOT_OPENED;  }    ret = hid_init_parser(hidif);  if (ret != HID_RET_SUCCESS) {    hid_close(hidif);    return ret;  }  ret = hid_prepare_hid_descriptor(hidif);  if (ret != HID_RET_SUCCESS) {    hid_close(hidif);    return ret;  }  ret = hid_prepare_report_descriptor(hidif);  if (ret != HID_RET_SUCCESS) {    hid_close(hidif);    return ret;  }  ret = hid_prepare_parser(hidif);  if (ret != HID_RET_SUCCESS) {    hid_close(hidif);    return ret;  }  return HID_RET_SUCCESS;}

static void pci_bus_probe (struct pci_info * pci, uint8_t bus){    uint8_t dev;    uint8_t dev_found = 0;    struct pci_bus * bus_ptr = NULL;    for (dev = 0; dev < PCI_MAX_DEV; dev++) {        if (pci_get_vendor_id(bus, dev, 0) != 0xffff) {            dev_found = 1;            break;        }    }    if (dev_found) {        bus_ptr = pci_bus_create(bus, pci);        if (!bus_ptr) {            ERROR_PRINT("Could not create PCI bus/n");            return;        }        for (dev = 0; dev < PCI_MAX_DEV; dev++) {            pci_dev_probe(bus_ptr, dev);        }    }}

    //------------------------------------------------------------------------    bool platform_support::create_img(unsigned idx, unsigned width, unsigned height)    {        if(idx < max_images)        {            if(m_specific->m_surf_img[idx]) SDL_FreeSurface(m_specific->m_surf_img[idx]);             m_specific->m_surf_img[idx] =                  SDL_CreateRGBSurface(SDL_SWSURFACE,                                       width,                                       height,                                      m_specific->m_surface->format->BitsPerPixel,                                      m_specific->m_rmask,                                       m_specific->m_gmask,                                       m_specific->m_bmask,                                       m_specific->m_amask);            if(m_specific->m_surf_img[idx] == 0)             {                ERROR_PRINT( "Couldn't create image: %s/n", SDL_GetError());                return false;            }            m_rbuf_img[idx].attach((unsigned char*)m_specific->m_surf_img[idx]->pixels,                                    m_specific->m_surf_img[idx]->w,                                    m_specific->m_surf_img[idx]->h,                                    m_flip_y ? -m_specific->m_surf_img[idx]->pitch :                                                m_specific->m_surf_img[idx]->pitch);            return true;        }        return false;    }

int main(int argc, char **argv){    int ret = 0;    	if(tapp_sigaction() != E_TLIBC_NOERROR)	{		ret = 1;		ERROR_PRINT("tapp_sigaction(), errno %d.", errno);		goto done;	}    tapp_load_config(&g_config, argc, argv, (tapp_xml_reader_t)tlibc_read_tlogd_config);	if(init() != E_TLIBC_NOERROR)	{		ret = 1;		goto done;	}	if(tapp_loop(TAPP_IDLE_USEC, TAPP_IDLE_LIMIT				 , tbusapi_process, &g_tbusapi	             , NULL, NULL) != E_TLIBC_NOERROR)	{		ret = 1;	}	fini();done:    return ret;}

voidpartition(p_arr arr, p_arr tmp, lint * bin_idx){  int N = arr->idx;  int* histogram = (int*) _mm_malloc(sizeof(int)*NUMENTRIESPERTABLE*num_threads, 64);  int* position = (int*) _mm_malloc(sizeof(int)*N, 64);  int right_shift = (int)(log2(g_v_num))-8;    #pragma omp parallel num_threads(num_threads)  {    int i, t;     int threadid = omp_get_thread_num();    int p_per_thread = N/num_threads;    if((p_per_thread * num_threads) != N) p_per_thread++;    int start_n = p_per_thread*threadid;    int end_n = start_n + p_per_thread;    if (end_n > N) end_n = N;    memset(histogram + threadid*NUMENTRIESPERTABLE, 0, sizeof(int)*NUMENTRIESPERTABLE);    for (i = start_n; i < end_n; i++) {      int finalHash = arr->arr[i].int_val1 >> right_shift;      position[i] = histogram[threadid*NUMENTRIESPERTABLE + finalHash];      histogram[threadid*NUMENTRIESPERTABLE + finalHash]++;    }//__BARRIER__;TREE_BARRIER(&tree_barrier, threadid, num_threads);#pragma omp single     {      int current_sum = 0;      int prev_sum = 0;      memset(bin_idx, 0, sizeof(int)*(NUMENTRIESPERTABLE+1));      bin_idx[0] = 0;      for (i = 0; i < NUMENTRIESPERTABLE; i++) {        for (t = 0; t < num_threads; t++) {          //cumsum[i] += histogram[t*NUMENTRIESPERTABLE + i-1];          current_sum = prev_sum + histogram[t*NUMENTRIESPERTABLE + i];          histogram[t*NUMENTRIESPERTABLE + i] = prev_sum;          prev_sum = current_sum;        }        //cumsum[i] += cumsum[i-1];        bin_idx[i+1] = current_sum;      }      if(current_sum != N) ERROR_PRINT();    }//__BARRIER__;TREE_BARRIER(&tree_barrier, threadid, num_threads);    for (i = start_n; i < end_n; i++) {      int finalHash = arr->arr[i].int_val1 >> right_shift;      int newIndex = histogram[threadid*NUMENTRIESPERTABLE + finalHash] + position[i];      tmp->arr[newIndex] = arr->arr[i];    }  }  _mm_free(histogram);  _mm_free(position);}

static int smt113j_spi_probe(struct spi_device *spi){	int ret;		DEBUG_PRINT("smt113j_spi_probe : Start!");		spi->bits_per_word = 8;	spi->mode = SPI_MODE_0;	spi->max_speed_hz = (27 * 1000 * 1000); /* 30MHz */	ret = spi_setup ( spi );	if ( ret < 0 ) 	{		ERROR_PRINT("smt113j_spi_probe : spi_setup Failed = %d!", ret );		return ( ret );	}	smt113j_spi_device = spi;	wake_lock_init ( &smt113j_spi_wake_lock, 					 WAKE_LOCK_SUSPEND, 					 "smt113j_spi_wake_lock" );		DEBUG_PRINT("smt113j_spi_probe : End!");	return ( 0 );}

int main(int argc, char **argv){    int ret = 0;    	if(tapp_sigaction() != E_TLIBC_NOERROR)	{    	ERROR_PRINT("tapp_sigaction failed.");		goto ERROR_RET;	}    tapp_load_config(&g_config, argc, argv, (tapp_xml_reader_t)tlibc_read_tconnd_config);    	if(init() != E_TLIBC_NOERROR)	{		goto ERROR_RET;	}       if(tapp_loop(TAPP_IDLE_USEC, TAPP_IDLE_LIMIT                , process, NULL                , NULL, NULL) == E_TLIBC_NOERROR)    {        ret = 0;    }    else    {        ret = 1;    }	fini();	return 0;ERROR_RET:	return 1;}

intobjtable_insert(struct memsection *memsection){    int     cmp;    struct  memsection *closest;    if (root == NULL)    {        root = memsection;    }    else    {        closest = find_node(root, objtable_key(memsection), &cmp, NULL);        if (cmp == 0)        {            ERROR_PRINT            (                "Failed to insert object into objtable (ms_base: %" PRIxPTR ")/n",                objtable_key(memsection)            );            return -1;          /* Key clash */        }        else if (cmp < 0)        {            closest->left = memsection;        }        else        {            closest->right = memsection;        }    }    return 0;}

static int SMT113J_SPI_release(struct inode *inode, struct file *filp){	int ret = 0;	DEBUG_PRINT("SMT113J_SPI_release << Start >>");	/*** Device Open Check ***/	if ( 0 == spi_open_cnt )	{		ERROR_PRINT ("No Open Devices");		return ( ret );	}	spi_open_cnt--;		if ( 0 != spi_open_cnt )	{		ERROR_PRINT ("Not Relase : Open Device Num[%d]", spi_open_cnt );		return ( ret );	}		/*** Private Data Area Check ***/	if ( NULL == (unsigned char *)filp->private_data )	{		ERROR_PRINT("No Private Data");		return ( ret );	}	/*** thread stop ***/	smt113j_spi_thread_Stop();		memset ( (unsigned char *)filp->private_data,			 0,			 sizeof ( smt113j_ioctl_data ));	kfree ( filp->private_data );			filp->private_data = NULL;		/*** buffer clear ***/	memset ( rx_pkt_buffer, 0, MAX_BUFFER_PKT * PAKCET_SIZE );	pwrite = 0;	pread  = 0;		DEBUG_PRINT("SMT113J_SPI_release << End >>");	return ret;}

int init_regulator(struct device *dev){    int rc = 1;    ant_sw_2p85 = devm_regulator_get(dev, "ANT_SW_2p85");    if (IS_ERR(ant_sw_2p85)) {        ERROR_PRINT("%s: unable to get antenna sw 2.85v/n", __func__);        return -1;    }    rc = regulator_set_voltage(ant_sw_2p85, ANT_SW_PHY_2P85_VOL_MIN,                               ANT_SW_PHY_2P85_VOL_MAX);    if (rc) {        ERROR_PRINT("%s: unable to get antenna sw 2.85v/n", __func__);        return -1;    }    return rc;}

int parseMoveFromTerminal(void) {	char line[MAX_MOVE_LEN];	if(fgets(line, MAX_MOVE_LEN, stdin)) {		ERROR_PRINT("Failed to read move from command line");		exit(1);	}	return parseMove(line);}

bool MCP::turnSw(byte num) {	if ((num == -1) || (num == 255)) {		ERROR_PRINT("ERROR: MCP.turnSw num = ");		ERROR_PRINTLN(num);		return false;	}	return turnSw(num, !actStates.msw[num]);}

intidt_assign_entry (ulong_t entry, ulong_t handler_addr){    if (entry >= NUM_IDT_ENTRIES) {        ERROR_PRINT("Assigning invalid IDT entry/n");        return -1;    }    if (!handler_addr) {        ERROR_PRINT("attempt to assign null handler/n");        return -1;    }    handler_table[entry] = handler_addr;    return 0;}

int parseMoveFromFile(char *fileName) {	FILE *fp = fopen(fileName, "r");	if (fp == NULL) {		ERROR_PRINT("Couldn't find file: %s", fileName);		exit(1);	}	char line[MAX_MOVE_LEN];	if (fgets(line, MAX_MOVE_LEN, fp) == NULL) {		ERROR_PRINT("Move is missing");		return MOVE_INVALID;	}	fclose(fp);	return parseMove(line);}

voidasciiBoxes_addJoinedBox(        BoxContainer* container,        int line,        int startColumn,        int endColumn,        bstring label){    if ( line >= container->numLines )    {        ERROR_PRINT(line id %d too large,line);    }    if ( endColumn >= container->numColumns )    {        ERROR_PRINT(column id %d too large,endColumn);    }    container->boxes[line][startColumn].width = (endColumn-startColumn)+1;    container->boxes[line][startColumn].label = bstrcpy(label);}

intsetup_idt (void){    uint_t i;    ulong_t irq_start = (ulong_t)&early_irq_handlers;    ulong_t excp_start = (ulong_t)&early_excp_handlers;    // clear the IDT out    memset(&idt64, 0, sizeof(struct gate_desc64) * NUM_IDT_ENTRIES);    for (i = 0; i < NUM_EXCEPTIONS; i++) {        set_intr_gate(idt64, i, (void*)(excp_start + i*16));        idt_assign_entry(i, (ulong_t)null_excp_handler);    }    for (i = 32; i < NUM_IDT_ENTRIES; i++) {        set_intr_gate(idt64, i, (void*)(irq_start + (i-32)*16));        idt_assign_entry(i, (ulong_t)null_irq_handler);    }    if (idt_assign_entry(PF_EXCP, (ulong_t)nk_pf_handler) < 0) {        ERROR_PRINT("Couldn't assign page fault handler/n");        return -1;    }    if (idt_assign_entry(DF_EXCP, (ulong_t)df_handler) < 0) {        ERROR_PRINT("Couldn't assign double fault handler/n");        return -1;    }    if (idt_assign_entry(0xf, (ulong_t)pic_spur_int_handler) < 0) {        ERROR_PRINT("Couldn't assign PIC spur int handler/n");        return -1;    }    lidt(&idt_descriptor);    return 0;}