bool NetSystem::Init()
{
	WSAData wsa_data;
	int error = WSAStartup(MAKEWORD(2, 2), &wsa_data);
	if (error == 0) {
		NetMessageDefinition pingDef;
		pingDef.m_callback = PingCallback;
		pingDef.m_name = "ping";
		pingDef.m_options |= eNMO_Connectionless;
		NetMessage::RegisterMessageDefinition(0, pingDef);

		NetMessageDefinition pongDef;
		pongDef.m_callback = PongCallback;
		pongDef.m_name = "pong";
		pongDef.m_options |= eNMO_Connectionless;
		NetMessage::RegisterMessageDefinition(1, pongDef);

		NetMessageDefinition heartbeatDef;
		heartbeatDef.m_callback = HeartbeatCallback;
		heartbeatDef.m_name = "heartbeat";
		NetMessage::RegisterMessageDefinition(2, heartbeatDef);

		NetMessageDefinition ackDef;
		ackDef.m_callback = AckCallback;
		ackDef.m_name = "ack";
		NetMessage::RegisterMessageDefinition(3, ackDef);

		NetMessageDefinition joinRequest;
		joinRequest.m_callback = JoinRequestCallback;
		joinRequest.m_name = "joinrequest";
		joinRequest.m_options |= eNMO_Reliable;
		joinRequest.m_options |= eNMO_Connectionless;
		NetMessage::RegisterMessageDefinition(4, joinRequest);

		NetMessageDefinition joinAccept;
		joinAccept.m_callback = JoinAcceptCallback;
		joinAccept.m_name = "joinaccept";
		joinAccept.m_options |= eNMO_Reliable;
		NetMessage::RegisterMessageDefinition(5, joinAccept);

		NetMessageDefinition joinDeny;
		joinDeny.m_callback = JoinDenyCallback;
		joinDeny.m_name = "joindeny";
		joinDeny.m_options |= eNMO_Connectionless;
		NetMessage::RegisterMessageDefinition(6, joinDeny);

		NetMessageDefinition leave;
		leave.m_callback = LeaveCallback;
		leave.m_name = "leave";
		NetMessage::RegisterMessageDefinition(7, leave);

		NetMessageDefinition startTest;
		startTest.m_callback = StartTestCallback;
		startTest.m_name = "starttest";
		startTest.m_options |= eNMO_Reliable;
		NetMessage::RegisterMessageDefinition(8, startTest);


		NetMessageDefinition inOrderTest;
		inOrderTest.m_callback = InOrderTestCallback;
		inOrderTest.m_name = "inordertest";
		inOrderTest.m_options |= eNMO_Reliable;
		inOrderTest.m_options |= eNMO_InOrder;
		NetMessage::RegisterMessageDefinition(9, inOrderTest);

		NetMessageDefinition forceTest;
		forceTest.m_callback = ForceTestCallback;
		forceTest.m_name = "forcetest";
		forceTest.m_options |= eNMO_Reliable;
		NetMessage::RegisterMessageDefinition(10, forceTest);

		return true;
	}
	else {
		FATAL_ERROR("Could not setup WSA System");
	}

	//Create netmessage definitions here
}

 /**
  * @brief For Numeric TypeInstances, get this TypeInstance's value as an
  *        int64_t.
  * @warning supportsNumericInterface() must be true and isNull() must be
  *          false for this method to be usable.
  *
  * @return The value as an int64_t.
  **/
 virtual std::int64_t numericGetLongValue() const {
   FATAL_ERROR("Used a Numeric interface method on a non-numeric TypeInstance.");
 }

 /**
  * @brief For Numeric TypeInstances, get this TypeInstance's value as a C++
  *        double.
  * @warning supportsNumericInterface() must be true and isNull() must be
  *          false for this method to be usable.
  *
  * @return The value as a double.
  **/
 virtual double numericGetDoubleValue() const {
   FATAL_ERROR("Used a Numeric interface method on a non-numeric TypeInstance.");
 }

/**
* pm_execute
* @params
*   int should_wait - Indicates if this execute should be inline or asynchronous
*   const char* command - The command to run
*   const char* cd - Run in this directory unless it's a NULL pointer
*   int nice - Special nice level
*   const char** env - Environment variables to run in the shell
* @output
    pid_t pid - output pid of the new process
**/
pid_t pm_execute(
  int should_wait, const char* command, const char *cd, int nice, const char** env, int *child_stdin, const char* p_stdout, const char *p_stderr
) {
  // Setup execution
  char **command_argv = {0};
  int command_argc = 0;
  int running_script = 0;
  int countdown = 200;
  
  // If there is nothing here, don't run anything :)
  if (strlen(command) == 0) return -1;
  
  char* chomped_string = str_chomp(command);
  char* safe_chomped_string = str_safe_quote(chomped_string);
  if (expand_command((const char*)safe_chomped_string, &command_argc, &command_argv, &running_script, env)) ;
  command_argv[command_argc] = 0;
      
  // Now actually RUN it!
  pid_t pid;
  
#if USE_PIPES

  int child_fd[2];
  if ( pipe(child_fd) < 0 ) {// Create a pipe to the child (do we need this? I doubt it)
    perror("pipe failed");
  }
  // Setup the stdin so the parent can communicate!
  (*child_stdin) = child_fd[0];
#endif

    // Let's name it so we can get to it later
  int child_dev_null;
  
#if DEBUG
  if ((child_dev_null = open("debug.log", O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) {
    syslog(LOG_ERR, "babysitter (fatal): Could not open debug.log: errno: %d\n", errno);
  };
#else
  if ((child_dev_null = open("/dev/null", O_RDWR)) < 0) {
    syslog(LOG_ERR, "babysitter (fatal): Could not open /dev/null: errno: %d\n", errno);
  };
#endif
    
  // Setup fork
  pm_setup_fork();
  
  if (should_wait)
    pid = vfork();
  else
    pid = fork();
    
  switch (pid) {
  case -1: 
    return -1;
  case 0: {
    // Child process
    pm_setup_child();
    
    if (cd != NULL && cd[0] != '\0')
      safe_chdir(cd);
    else
      safe_chdir("/tmp");
        
    int child_stdout, child_stderr;
    // Set everything to dev/null first
    child_stdout = child_stderr = child_dev_null;
    
    // If we've passed in a stdout filename, then open it
    if(p_stdout)
      if ((child_stdout = open(p_stdout, O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) {
        perror("child stdout");
        child_stdout = child_dev_null;
      }
    // If we've been passed a stderr filename, then open that
    if(p_stderr)
      if ((child_stderr = open(p_stderr, O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) {
        perror("child stderr");
        child_stderr = child_dev_null;
      }
    
    // Parent doesn't write anything to the child, so just close this right away
    // REDIRECT TO DEV/NULL
    // Replace the stdout/stderr with the child_write fd
#if USE_PIPES
    if (dup2(child_fd[0], STDIN_FILENO) < 0)       FATAL_ERROR("could not dup STDIN_FILENO", -1);
    close(child_fd[1]); // We are using a different stdout
#endif

#if DEBUG
//.........这里部分代码省略.........

std::string PlayerSAO::getStaticData()
{
	FATAL_ERROR("Deprecated function (?)");
	return "";
}

OCLAcceleratorMatrixCOO<ValueType>::OCLAcceleratorMatrixCOO() {

  // no default constructors
  FATAL_ERROR(__FILE__, __LINE__);

}

void SampleLoopTask::Task(){
		
	int cnt = 0;
	int region;
	int attempt = 0;
	
	static int dout = 1;
	static double error = 0;
	
	int last_status = 0;
	double pos_prev = 0;
	double pCmd_prev = 0;
	double vCmd_prev = 0;
		
	int obj_ang_index = 0; // to keep continuous angle value when acrossing pi(or -pi).
	uint64_t cycle, cycle_prev;

	// for acceleration calculation
	double u = 0; 
	double alpha = 0;
	double DuDeta1Bar =0;
	double DuDeta2 =0; 
	double DalphaDeta1Bar =0;
	double DalphaDeta2 =0; 
	double eta1Bar = 0; 
	double z = 0;
	
	// to use eta2D in calculation of shD
	double eta2_prev = 0; 
	double eta2D = 0; 
	double eta2D_prev = 0; 
	
	double elapsedSec = 0;

	//test
	double feedforwardVal = 0;
	uint64_t cycle1, cycle2;

	while(!lost){
		TimerWait();
		
		ncycles = ClockCycles();
		sec=(double)(ncycles - ncycles_prev)/cps;
		ncycles_prev = ncycles;
		
		TimingProcess();
		
		// Read Inputs
		HW->ProcessInput(); // all digital & analog, encoders reading.
		
		// Get status of camera
		last_status = HW->ReadDigitalBit(IoHardware::FRAME_STATUS);
		
		// Send out pulse to trigger camera
		HW->WriteDigitalBit(IoHardware::CAMERA_TRIGGER, 1);
		HW->WriteDigitalBit(IoHardware::CAMERA_TRIGGER, 0);
		
		// test
		//cycle1 = ClockCycles();

		if(camera) {// && !lost){
			// Wait for camera to process data, with timeout counter
			while(HW->ReadDigitalBit(IoHardware::FRAME_STATUS) == last_status){
				if(++attempt == (int)(6.0e5/SAMPLE_RATE)) { // 5.0e5 must be found out by experiments to give the smallest time to determine an error status
					HW->SetAnalogOut(IoHardware::AMP_SIGNAL, 0.0); 
					HW->WriteDigitalBit(IoHardware::MOTOR_ENABLE, MOTOR_OFF);
					HW->motorStatus = MOTOR_OFF;
					lost = 1;
					FATAL_ERROR("Frame not received -");
					//strcpy(err_msg, "Frame not received -"); // // not work this way.
				}
			}
			attempt = 0;
			
			vnum[0] = -99;
			int n = VNET->Recv();

			region = (int)vnum[0];
			switch(region){
				case 0: //ROI_0:
					obj.x0 = vnum[1]; //mm
					obj.y0 = vnum[2]; //mm
					break;
				case 1: //ROI_1:
					obj.x1 = vnum[1]; //mm
					obj.y1 = vnum[2]; //mm
					break;
				default:
					HW->SetAnalogOut(IoHardware::AMP_SIGNAL, 0.0); 
					HW->WriteDigitalBit(IoHardware::MOTOR_ENABLE, MOTOR_OFF);
					HW->motorStatus = MOTOR_OFF;
					printf("roi-vnum[0]:%d\n", region);
					FATAL_ERROR("Object lost -");
					lost = 1;
			}
			
			obj.x = (obj.x0 + obj.x1)/2/1000; // convert to m
			obj.y = (obj.y0 + obj.y1)/2/1000;
			double obj_raw_angle = atan2(obj.y1-obj.y0, obj.x1-obj.x0); // within -pi to pi

//.........这里部分代码省略.........

void load_conf(void)
{
    FILE *fc;
    char line[128];
    char *p, *q, **tmp;
    int lineno = 0;
    struct conf_entry *curr_section = NULL;
    void *value = NULL;

    /* initialize the structures */
    init_structures();

    DEBUG_MSG("load_conf");

    /* the user has specified an alternative config file */
    if (GBL_CONF->file) {
        DEBUG_MSG("load_conf: alternative config: %s", GBL_CONF->file);
        fc = fopen(GBL_CONF->file, FOPEN_READ_TEXT);
        ON_ERROR(fc, NULL, "Cannot open %s", GBL_CONF->file);
    } else {
        /* errors are handled by the function */
        fc = open_data("etc", ETTER_CONF, FOPEN_READ_TEXT);
        ON_ERROR(fc, NULL, "Cannot open %s", ETTER_CONF);
    }

    /* read the file */
    while (fgets(line, 128, fc) != 0) {

        /* update the line count */
        lineno++;

        /* trim out the comments */
        if ((p = strchr(line, '#')))
            *p = '\0';

        /* trim out the new line */
        if ((p = strchr(line, '\n')))
            *p = '\0';

        q = line;

        /* trim the initial spaces */
        while (q < line + sizeof(line) && *q == ' ')
            q++;

        /* skip empty lines */
        if (line[0] == '\0' || *q == '\0')
            continue;

        /* here starts a new section [...] */
        if (*q == '[') {

            /* remove the square brackets */
            if ((p = strchr(line, ']')))
                *p = '\0';
            else
                FATAL_ERROR("Missing ] in %s line %d", ETTER_CONF, lineno);

            p = q + 1;

            DEBUG_MSG("load_conf: SECTION: %s", p);

            /* get the pointer to the right structure */
            if ( (curr_section = search_section(p)) == NULL)
                FATAL_ERROR("Invalid section in %s line %d", ETTER_CONF, lineno);

            /* read the next line */
            continue;
        }

        /* variable outside a section */
        if (curr_section == NULL)
            FATAL_ERROR("Entry outside a section in %s line %d", ETTER_CONF, lineno);

        /* sanity check */
        if (!strchr(q, '='))
            FATAL_ERROR("Parse error %s line %d", ETTER_CONF, lineno);

        p = q;

        /* split the entry name from the value */
        do {
            if (*p == ' ' || *p == '=') {
                *p = '\0';
                break;
            }
        } while (p++ < line + sizeof(line) );

        /* move p to the value */
        p++;
        do {
            if (*p != ' ' && *p != '=')
                break;
        } while (p++ < line + sizeof(line) );

        /*
         * if it is the "dissector" section,
         * do it in a different way
         */
        if (curr_section == (struct conf_entry *)&dissectors) {
//.........这里部分代码省略.........

static bool ParseFile(FILE *pFile) {
    uint8_t size;

    if(pFile == NULL) {
        FATAL_ERROR();
        return false;
    }

    fread(&size, sizeof(char), 1, pFile);
    fread(room.title, sizeof(char), size, pFile);
    room.title[size] = '\0';
    fread(&size, sizeof(char), 1, pFile);
    if(size == 0) {
        room.itemRequirements = 0;
    } else {
        fread(&room.itemRequirements, sizeof(char), size, pFile);
    }

    while(!FindInInventory(room.itemRequirements) || room.itemRequirements) {
        fread(&size, sizeof(char), 1, pFile);
        fseek(pFile, size, SEEK_CUR);

        fread(&size, sizeof(char), 1, pFile);
        fread(&room.itemsContained, sizeof(char), size, pFile);

        fseek(pFile, 4, SEEK_CUR);
        fread(&size, sizeof(char), 1, pFile);
        if(size == 0) {
            room.itemRequirements = 0;
        } else {
            fread(&room.itemRequirements, sizeof(char), size, pFile);
        }
    }
    fread(&size, sizeof(char), 1, pFile);
    fread(room.description, sizeof(char), size, pFile);
    room.description[size] = '\0';

    fread(&size, sizeof(char), 1, pFile);
    if(size != 0) {
        fread(&room.itemsContained, sizeof(char), size, pFile);
        AddToInventory(room.itemsContained);
    } else {
        room.itemsContained = 0;
    }

    fread(&room.north, sizeof(uint8_t), 1, pFile);
    fread(&room.east, sizeof(uint8_t), 1, pFile);
    fread(&room.south, sizeof(uint8_t), 1, pFile);
    fread(&room.west, sizeof(uint8_t), 1, pFile);

    room.roomExits = 0;

    if(room.north) {
        room.roomExits |= GAME_ROOM_EXIT_NORTH_EXISTS;
    }
    if(room.east) {
        room.roomExits |= GAME_ROOM_EXIT_NORTH_EXISTS;
    }
    if(room.south) {
        room.roomExits |= GAME_ROOM_EXIT_SOUTH_EXISTS;
    }
    if(room.west) {
        room.roomExits |= GAME_ROOM_EXIT_WEST_EXISTS;
    }

    fclose(pFile);
    return true;
}

/**
 * This function calls ButtonsCheckEvents() once per call and returns which, if any,
 * of the Morse code events listed in the enum above have been encountered. It checks for BTN4
 * events in its input and should be called at 100Hz so that the timing works. The
 * length that BTN4 needs to be held down for a dot is >= 0.25s and < 0.50s with a dash being a button
 * down event for >= 0.5s. The button uptime various between dots/dashes (>= .5s), letters
 * (>= 1s), and words (>= 2s).
 *
 * @note This function assumes that the buttons are all unpressed at startup, so that the first
 *       event it will see is a BUTTON_EVENT_*DOWN.
 *
 * So pressing the button for 0.1s, releasing it for 0.1s, pressing it for 0.3s, and then waiting
 * will decode the string '.-' (A). It will trigger the following order of events:
 * 9 MORSE_EVENT_NONEs, 1 MORSE_EVENT_DOT, 39 MORSE_EVENT_NONEs, a MORSE_EVENT_DASH, 69
 * MORSE_EVENT_NONEs, a MORSE_EVENT_END_CHAR, and then MORSE_EVENT_INTER_WORDs.
 *
 * @return The MorseEvent that occurred.
 */
MorseEvent MorseCheckEvents(void) {

    switch (myState) {
        case(WAITING):
        {// if in the state of waiting
            if (ButtonsCheckEvents() == BUTTON_EVENT_4DOWN) {
                myState = DOT;
                myCount = 0;
            }
            return MORSE_EVENT_NONE;
            break;
        }
        case(DOT):
        {
            // in the state of dot
            myCount += 1;
            if (myCount >= MORSE_EVENT_LENGTH_DOWN_DOT) {
                myState = DASH;
            }
            if (ButtonsCheckEvents() == BUTTON_EVENT_4UP) {
                // Chenge into Inter letter
                myState = INTER_LETTER;
                myCount = 0;
                return MORSE_EVENT_DOT;

            }
            return MORSE_EVENT_NONE;
            break;
        }
        case(DASH):
        {
            //in Dash state
            if (ButtonsCheckEvents() == BUTTON_EVENT_4UP) {
                // change my state to Inter letter
                myState = INTER_LETTER;
                myCount = 0;
                return MORSE_EVENT_DASH;

            }
            return MORSE_EVENT_NONE;
            break;
        }
        case(INTER_LETTER):
        {
            //In the inter letter state
            myCount += 1;
            if (myCount > MORSE_EVENT_LENGTH_UP_INTER_WORD) {
                //if inter letter time out, we go to
                myState = WAITING;
                return MORSE_EVENT_INTER_WORD;
            } else if (ButtonsCheckEvents() == BUTTON_EVENT_4DOWN) {
                //
                if (myCount > MORSE_EVENT_LENGTH_UP_INTER_LETTER) {
                    myCount = 0;
                    myState = DOT;
                    // return inter ltter event 
                    return MORSE_EVENT_INTER_LETTER;
                }
                myCount = 0;
                myState = DOT;
            }
            return MORSE_EVENT_NONE;
            break;
        }
        default:
        {
            //In the deflaut state
            FATAL_ERROR();
            break;
        }
    }
}

int main(void)
{
    // Watchdog Timer Enabled/disabled by user software
    // (LPRC can be disabled by clearing SWDTEN bit in RCON registe

    // Configure Oscillator to operate the device at 40Mhz
    // Fosc= Fin*M/(N1*N2), Fcy=Fosc/2
    // Fosc= 8M*40/(2*2)=80Mhz for 8M input clock
    PLLFBD = 38; // M=40
    CLKDIVbits.PLLPOST = 0; // N1=2
    CLKDIVbits.PLLPRE = 0; // N2=2
    OSCTUN = 0; // Tune FRC oscillator, if FRC is used

    RCONbits.SWDTEN = 0; /* Disable Watch Dog Timer*/

    // Clock switch to incorporate PLL
    __builtin_write_OSCCONH(0x03); // Initiate Clock Switch to Primary
    // Oscillator with PLL (NOSC=0b011)
    __builtin_write_OSCCONL(0x01); // Start clock switching
    while (OSCCONbits.COSC != 0b011); // Wait for Clock switch to occur

    while (OSCCONbits.LOCK != 1) {
    }; /* Wait for PLL to lock*/

//    bufferPointer = NULL;
    Uart2Init(InterruptRoutine);

    if (!CB_Init(&circBuf, cbData, CB_SIZE)) FATAL_ERROR();

    // Generate a fake input to record to the circular buffer
    // give beginning and end special characters
    unsigned char goodData[512];
    int i;
    for (i=0; i<512; i++) {
        goodData[i] = (char)i;
    }
    goodSum = checksum(goodData, 512);
    
    Uart2PrintStr("Begin.\n");
    file = NewSDInit("newfile.txt");

    int SDConnected = 0;
    while(1)
    {
//        if (bufferPointer != NULL) { TODO implement this?
//            CB_WriteMany(&circBuf, bufferPointer, UART2_BUFFER_SIZE, 1); // the 1 is arbitrary
//            bufferPointer = NULL;
//        }
        if (SD_IN)
        {
            // if the board was just plugged in try to reinitialize
            if(!SDConnected) {
                MEDIA_INFORMATION * Minfo;
                do {
                    Minfo = MDD_MediaInitialize();
                } while(Minfo->errorCode == MEDIA_CANNOT_INITIALIZE);
                SDConnected = 1;
            }
            // When we are connected and initialized, poll the buffer, if there
            // is data, write it.
            unsigned char outData[SD_SECTOR_SIZE];
            if (CB_PeekMany(&circBuf, outData, SD_SECTOR_SIZE)){
                if(NewSDWriteSector(file, outData)){
                    // Remove the data we just written.
                    if(checksum(outData, 512) != goodSum) {
                        FATAL_ERROR();
                    }
                    CB_Remove(&circBuf, SD_SECTOR_SIZE);
                }
            }
        } else {
            SDConnected = 0;
        }
    }
}

/*
 * concatenate two (or more) files into one single file 
 */
void concatenate(int argc, char **argv)
{
   int zerr;
   gzFile fd;
   struct log_global_header hdr, tmp;

   memset(&hdr, 0, sizeof(struct log_global_header));

   /* open the output file for writing */
   fd = gzopen(GBL_LOGFILE, "wb");
   ON_ERROR(fd, NULL, "%s", gzerror(fd, &zerr));

   /* 
    * use GBL_LOG_FD here so the get_header function
    * will use this file 
    */
   GBL_LOG_FD = gzopen(argv[argc], "rb");
   ON_ERROR(GBL_LOG_FD, NULL, "%s", gzerror(GBL_LOG_FD, &zerr));
   
   /* get the file header */
   if (get_header(&hdr) != E_SUCCESS)
      FATAL_ERROR("Invalid log file (%s)", argv[argc]);

   /* write the header */
   put_header(fd, &hdr);
      
   printf("Concatenating file [%s]", argv[argc]);
   
   /* copy the first file into the output */
   dump_file(fd, &hdr);
     
   /* move the pointer to the next file */
   argc++;
   
   /* cicle thru the file list */
   while(argv[argc] != NULL) {
   
      GBL_LOG_FD = gzopen(argv[argc], "rb");
      ON_ERROR(GBL_LOG_FD, NULL, "%s", gzerror(GBL_LOG_FD, &zerr));
   
      /* get the file header */
      if (get_header(&tmp) != E_SUCCESS)
         FATAL_ERROR("Invalid log file (%s)", argv[argc]);
     
      /* check if the files are compatible */
      if (hdr.type != tmp.type)
         FATAL_ERROR("Cannot concatenate different type of file");

      printf("Concatenating file [%s]", argv[argc]);
      
      /* concatenate this file */
      dump_file(fd, &tmp);

      gzclose(GBL_LOG_FD);
      argc++;
   }

   gzclose(fd);

   printf("\nAll files concatenated into: %s\n\n", GBL_LOGFILE);

   exit(0);
}

void initializePaths()
{
#if RUN_IN_PLACE
	char buf[BUFSIZ];

	infostream << "Using relative paths (RUN_IN_PLACE)" << std::endl;

	bool success =
		getCurrentExecPath(buf, sizeof(buf)) ||
		getExecPathFromProcfs(buf, sizeof(buf));

	if (success) {
		pathRemoveFile(buf, DIR_DELIM_CHAR);
		std::string execpath(buf);

		path_share = execpath + DIR_DELIM "..";
		path_user  = execpath + DIR_DELIM "..";

		if (detectMSVCBuildDir(execpath)) {
			path_share += DIR_DELIM "..";
			path_user  += DIR_DELIM "..";
		}
	} else {
		errorstream << "Failed to get paths by executable location, "
			"trying cwd" << std::endl;

		if (!getCurrentWorkingDir(buf, sizeof(buf)))
			FATAL_ERROR("Ran out of methods to get paths");

		size_t cwdlen = strlen(buf);
		if (cwdlen >= 1 && buf[cwdlen - 1] == DIR_DELIM_CHAR) {
			cwdlen--;
			buf[cwdlen] = '\0';
		}

		if (cwdlen >= 4 && !strcmp(buf + cwdlen - 4, DIR_DELIM "bin"))
			pathRemoveFile(buf, DIR_DELIM_CHAR);

		std::string execpath(buf);

		path_share = execpath;
		path_user  = execpath;
	}
	path_cache = path_user + DIR_DELIM + "cache";
#else
	infostream << "Using system-wide paths (NOT RUN_IN_PLACE)" << std::endl;

	if (!setSystemPaths())
		errorstream << "Failed to get one or more system-wide path" << std::endl;

	// Initialize path_cache
	// First try $XDG_CACHE_HOME/PROJECT_NAME
	const char *cache_dir = getenv("XDG_CACHE_HOME");
	const char *home_dir = getenv("HOME");
	if (cache_dir) {
		path_cache = std::string(cache_dir) + DIR_DELIM + PROJECT_NAME;
	} else if (home_dir) {
		// Then try $HOME/.cache/PROJECT_NAME
		path_cache = std::string(home_dir) + DIR_DELIM + ".cache"
			+ DIR_DELIM + PROJECT_NAME;
	} else {
		// If neither works, use $PATH_USER/cache
		path_cache = path_user + DIR_DELIM + "cache";
	}
	// Migrate cache folder to new location if possible
	migrateCachePath();
#endif

	infostream << "Detected share path: " << path_share << std::endl;
	infostream << "Detected user path: " << path_user << std::endl;
	infostream << "Detected cache path: " << path_cache << std::endl;

#if USE_GETTEXT
	bool found_localedir = false;
#  ifdef STATIC_LOCALEDIR
	if (STATIC_LOCALEDIR[0] && fs::PathExists(STATIC_LOCALEDIR)) {
		found_localedir = true;
		path_locale = STATIC_LOCALEDIR;
		infostream << "Using locale directory " << STATIC_LOCALEDIR << std::endl;
	} else {
		path_locale = getDataPath("locale");
		if (fs::PathExists(path_locale)) {
			found_localedir = true;
			infostream << "Using in-place locale directory " << path_locale
				<< " even though a static one was provided "
				<< "(RUN_IN_PLACE or CUSTOM_LOCALEDIR)." << std::endl;
		}
	}
#  else
	path_locale = getDataPath("locale");
	if (fs::PathExists(path_locale)) {
		found_localedir = true;
	}
#  endif
	if (!found_localedir) {
		warningstream << "Couldn't find a locale directory!" << std::endl;
	}
#endif  // USE_GETTEXT
}

void parse_options(int argc, char **argv)
{
   int c;

   static struct option long_options[] = {
      { "help", no_argument, NULL, 'h' },
      { "version", no_argument, NULL, 'v' },
      
      { "iface", required_argument, NULL, 'i' },
      { "iflist", no_argument, NULL, 'I' },
      { "netmask", required_argument, NULL, 'n' },
      { "write", required_argument, NULL, 'w' },
      { "read", required_argument, NULL, 'r' },
      { "pcapfilter", required_argument, NULL, 'f' },
      
      { "reversed", no_argument, NULL, 'R' },
      { "proto", required_argument, NULL, 't' },
      
      { "plugin", required_argument, NULL, 'P' },
      
      { "filter", required_argument, NULL, 'F' },
      
      { "superquiet", no_argument, NULL, 'Q' },
      { "quiet", no_argument, NULL, 'q' },
      { "script", required_argument, NULL, 's' },
      { "silent", no_argument, NULL, 'z' },
      { "unoffensive", no_argument, NULL, 'u' },
      { "load-hosts", required_argument, NULL, 'j' },
      { "save-hosts", required_argument, NULL, 'k' },
      { "wep-key", required_argument, NULL, 'W' },
      { "config", required_argument, NULL, 'a' },
      
      { "dns", no_argument, NULL, 'd' },
      { "regex", required_argument, NULL, 'e' },
      { "visual", required_argument, NULL, 'V' },
      { "ext-headers", no_argument, NULL, 'E' },
      
      { "log", required_argument, NULL, 'L' },
      { "log-info", required_argument, NULL, 'l' },
      { "log-msg", required_argument, NULL, 'm' },
      { "compress", no_argument, NULL, 'c' },
      
      { "text", no_argument, NULL, 'T' },
      { "curses", no_argument, NULL, 'C' },
      { "gtk", no_argument, NULL, 'G' },
      { "daemon", no_argument, NULL, 'D' },
      
      { "mitm", required_argument, NULL, 'M' },
      { "only-mitm", no_argument, NULL, 'o' },
      { "bridge", required_argument, NULL, 'B' },
      { "promisc", no_argument, NULL, 'p' },
      
      { 0 , 0 , 0 , 0}
   };


#ifdef HAVE_GTK 
      if (strcmp(argv[0], "ettercap-gtk") == 0)
          select_gtk_interface();
#endif
#ifdef HAVE_NCURSES 
      if (strcmp(argv[0], "ettercap-curses") == 0)
          select_curses_interface();
#endif
      if (strcmp(argv[0], "ettercap-text") == 0)
          select_text_interface();

   for (c = 0; c < argc; c++)
      DEBUG_MSG("parse_options -- [%d] [%s]", c, argv[c]);

   
/* OPTIONS INITIALIZATION */
   
   GBL_PCAP->promisc = 1;
   GBL_FORMAT = &ascii_format;

/* OPTIONS INITIALIZED */
   
   optind = 0;

   while ((c = getopt_long (argc, argv, "a:B:CchDdEe:F:f:GhIi:j:k:L:l:M:m:n:oP:pQqiRr:s:Tt:UuV:vW:w:z", long_options, (int *)0)) != EOF) {

      switch (c) {

         case 'M':
                  GBL_OPTIONS->mitm = 1;
                  if (mitm_set(optarg) != ESUCCESS)
                     FATAL_ERROR("MITM method '%s' not supported...\n", optarg);
                  break;
                  
         case 'o':
                  GBL_OPTIONS->only_mitm = 1;
                  //select_text_interface();
                  break;
                  
         case 'B':
                  GBL_OPTIONS->iface_bridge = strdup(optarg);
                  set_bridge_sniff();
                  break;
                  
//.........这里部分代码省略.........

void OCLAcceleratorMatrixCOO<ValueType>::CopyTo(BaseMatrix<ValueType> *dst) const {

  OCLAcceleratorMatrixCOO<ValueType> *ocl_cast_mat;
  HostMatrix<ValueType> *host_cast_mat;

  // copy only in the same format
  assert(this->get_mat_format() == dst->get_mat_format());

  // OCL to OCL copy
  if ((ocl_cast_mat = dynamic_cast<OCLAcceleratorMatrixCOO<ValueType>*> (dst)) != NULL) {

    ocl_cast_mat->set_backend(this->local_backend_);       

    if (this->get_nnz() == 0)
      ocl_cast_mat->AllocateCOO(dst->get_nnz(), dst->get_nrow(), dst->get_ncol() );

    assert((this->get_nnz()  == dst->get_nnz())  &&
	   (this->get_nrow() == dst->get_nrow()) &&
	   (this->get_ncol() == dst->get_ncol()) );

    if (this->get_nnz() > 0) {

      // Copy object from device to device memory (internal copy)
      ocl_dev2dev<int>(this->get_nnz(), // size
                       this->mat_.row,         // src
                       ocl_cast_mat->mat_.row, // dst
                       OCL_HANDLE(this->local_backend_.OCL_handle)->OCL_cmdQueue );

      // Copy object from device to device memory (internal copy)
      ocl_dev2dev<int>(this->get_nnz(), // size
                       this->mat_.col,         // src
                       ocl_cast_mat->mat_.col, // dst
                       OCL_HANDLE(this->local_backend_.OCL_handle)->OCL_cmdQueue );

      // Copy object from device to device memory (internal copy)
      ocl_dev2dev<ValueType>(this->get_nnz(), // size
                             this->mat_.val,         // src
                             ocl_cast_mat->mat_.val, // dst
                             OCL_HANDLE(this->local_backend_.OCL_handle)->OCL_cmdQueue );

    }
    
  } else {

    //OCL to CPU
    if ((host_cast_mat = dynamic_cast<HostMatrix<ValueType>*> (dst)) != NULL) {
      
      this->CopyToHost(host_cast_mat);

    } else {
      
      LOG_INFO("Error unsupported OCL matrix type");
      this->info();
      dst->info();
      FATAL_ERROR(__FILE__, __LINE__);
      
    }

  }


}

int main(int argc, char *argv[])
{
   int ret;
   /* etterlog copyright */
   globals_alloc();
   fprintf(stdout, "\n" EC_COLOR_BOLD "%s %s" EC_COLOR_END " copyright %s %s\n\n", 
                      GBL_PROGRAM, EC_VERSION, EC_COPYRIGHT, EC_AUTHORS);
  
  
   /* allocate the global target */
   SAFE_CALLOC(GBL_TARGET, 1, sizeof(struct target_env));
  
   /* initialize to all target */
   GBL_TARGET->all_mac = 1;
   GBL_TARGET->all_ip = 1;
   GBL_TARGET->all_port = 1;
   
   /* getopt related parsing...  */
   parse_options(argc, argv);

   /* get the global header */
   ret = get_header(&GBL->hdr);
   if (ret == -EINVALID)
      FATAL_ERROR("Invalid log file");
   
   fprintf(stderr, "Log file version    : %s\n", GBL->hdr.version);
   /* display the date. ec_ctime() has no newline at end. */
   fprintf(stderr, "Timestamp           : %s [%lu]\n", ec_ctime(&GBL->hdr.tv), GBL->hdr.tv.tv_usec);
   fprintf(stderr, "Type                : %s\n\n", (GBL->hdr.type == LOG_PACKET) ? "LOG_PACKET" : "LOG_INFO" );
  
   
   /* analyze the logfile */
   if (GBL->analyze)
      analyze();

   /* rewind the log file and skip the global header */
   gzrewind(GBL_LOG_FD);
   get_header(&GBL->hdr);
   
   /* create the connection table (respecting the filters) */
   if (GBL->connections)
      conn_table_create();

   /* display the connection table */
   if (GBL->connections && !GBL->decode)
      conn_table_display();

   /* extract files from the connections */
   if (GBL->decode)
      conn_decode();
   
   /* not interested in the content... only analysis */
   if (GBL->analyze || GBL->connections)
      return 0;
   
   /* display the content of the logfile */
   display();
   
   globals_free();

   return 0;
}

static void
read_directory_file (void)
{
  char *strp;
  FILE *fp;
  char buf[512];		/* FIXME: use a symbol */
  static char *path = NULL;

  if (path == NULL)
    path = xmalloc (PATH_MAX);
  time (&time_now);
  if (listed_incremental_option[0] != '/'
#if DOSWIN
      /* The case of DOSWIN absolute file name with a drive letter.  */
      && !(listed_incremental_option[0] && listed_incremental_option[1] == ':')
#endif
      )
    {
      char *current_directory = xgetcwd ();

      if (!current_directory)
	FATAL_ERROR ((0, 0, _("Could not get current directory")));

      listed_incremental_option
	= concat_with_slash (current_directory, listed_incremental_option);
    }
  fp = fopen (listed_incremental_option, "r");
  if (fp == 0 && errno != ENOENT)
    {
      ERROR ((0, errno, _("Cannot open %s"), listed_incremental_option));
      return;
    }
  if (!fp)
    return;
  fgets (buf, sizeof (buf), fp);

  /* FIXME: Using newer_ctime_option as a first time flag looks fairly dubious
     to me!  So, using -N with incremental might be buggy just because of the
     next few lines.  I saw a few unexplained, almost harsh advices from FSF
     people about *not* using -N with incremental dumps, and here might lie
     (part of) the reason.  */
  if (!newer_ctime_option)
    {
      time_option_threshold = atol (buf);
      newer_ctime_option = true;
    }

  while (fgets (buf, sizeof (buf), fp))
    {
      dev_t device_number;
      ino_t inode_number;

      strp = &buf[strlen (buf)];
      if (strp[-1] == '\n')
	strp[-1] = '\0';
      /* FIXME: For files ending with an incomplete line, maybe a NUL might
	 be missing, here...  */

      strp = buf;
      device_number = atol (strp);
      while (ISDIGIT (*strp))
	strp++;
      inode_number = atol (strp);
      while (ISSPACE (*strp))
	strp++;
      while (ISDIGIT (*strp))
	strp++;
      strp++;
      unquote_string (strp);
      note_directory (strp, device_number, inode_number, NULL);
    }
  if (fclose (fp) == EOF)
    ERROR ((0, errno, "%s", listed_incremental_option));
}

//.........这里部分代码省略.........
                  GBL.only_source = 1;
                  break;
                  
         case 'd':
                  GBL.only_dest = 1;
                  break;
                  
         case 'k':
                  GBL.color = 1;
                  break;
                     
         case 'r':
                  GBL.reverse = 1;
                  break;
                  
         case 't':
                  GBL_TARGET->proto = strdup(optarg);
                  break;
                  
         case 'n':
                  GBL.no_headers = 1;
                  break;
                  
         case 'm':
                  GBL.showmac = 1;
                  break;
                  
         case 'i':
                  GBL.showclient = 1;
                  break;
                  
         case 'I':
                  if (inet_aton(optarg, &ip) == 0) {
                     FATAL_ERROR("Invalid client ip address");
                     return;                    
                  }
                  ip_addr_init(&GBL.client, AF_INET, (u_char *)&ip);
                  break;

         case 'l':
                  GBL.only_local = 1;
                  break;
         
         case 'L':
                  GBL.only_remote = 1;
                  break;
                  
         case 'u':
                  GBL.user = strdup(optarg);
                  break;
                  
         case 'p':
                  GBL.passwords = 1;
                  break;

         case 'e':
                  set_display_regex(optarg);
                  break;
                 
         case 'o':
                  GBL_LOGFILE = strdup(optarg);
                  break;
                  
         case 'C':
                  GBL.concat = 1;
                  break;

void PlayerSAO::getStaticData(std::string *result) const
{
	FATAL_ERROR("Deprecated function");
}