Ejemplo n.º 1
0
int new_part_tab(u8 *buf)
{
	DM_PARTITION_INFO_PACKET  *dm_part= (DM_PARTITION_INFO_PACKET *)buf;
	int part_num,change_index,i;
	int retval;
	int pageoffset;
	int start_addr=total_size+BLOCK_SIZE;
	int current_addr=0;
	
	pi.pt_changed =0;
	pi.tool_or_sd_update = 1;

	MSG (INIT, "new_pt par_nub  enter \n");
	//the first image is ?
	
	for(part_num=0;part_num<PART_MAX_COUNT;part_num++)
	{
		memcpy(new_part[part_num].name,dm_part->part_info[part_num].part_name,MAX_PARTITION_NAME_LEN);
		new_part[part_num].offset=dm_part->part_info[part_num].start_addr;
		new_part[part_num].size=dm_part->part_info[part_num].part_len;
		new_part[part_num].mask_flags=0;
		//MSG (INIT, "DM_PARTITION_INFO_PACKET %s size %x %x \n",dm_part->part_info[part_num].part_name,dm_part->part_info[part_num].part_len,part_num);
		MSG (INIT, "new_pt %s size %x \n",new_part[part_num].name,new_part[part_num].size);
		if(dm_part->part_info[part_num].part_len ==0)
		{
			MSG (INIT, "new_pt last %x \n",part_num);
			break;
		}
	}
	MSG (INIT, "new_pt par_nub %x \n",part_num);
	#if 1
	//++++++++++for test
	#if 0
	part_num=13;
	memcpy(&new_part[0],&lastest_part[0],sizeof(new_part));
	MSG (INIT, "new_part  %x size  \n",sizeof(new_part));
	for(i=0;i<part_num;i++)
	{
		MSG (INIT, "npt partition %s size  \n",new_part[i].name);
		//MSG (INIT, "npt %x size  \n",new_part[i].offset);
		//MSG (INIT, "npt %x size  \n",lastest_part[i].offset);
		//MSG (INIT, "npt %x size  \n",new_part[i].size);
		dm_part->part_info[5].part_visibility =1;
		dm_part->part_info[5].dl_selected =1;
		new_part[5].size = lastest_part[5].size+0x100000;
	}
	#endif
	//------------for test
	//Find the first changed partition, whether is visible
	for(change_index=0;change_index<=part_num;change_index++)
	{
		if((new_part[change_index].size!=lastest_part[change_index].size)||(new_part[change_index].offset!=lastest_part[change_index].offset))
		{
			MSG (INIT, "new_pt %x size changed from %x to %x\n",change_index,lastest_part[change_index].size,new_part[change_index].size);
			pi.pt_changed =1;
			break;
		}
	}

      if(pi.pt_changed==1)
      	{
		//Is valid image update
		for(i=change_index;i<=part_num;i++)
		{
			if(dm_part->part_info[i].dl_selected==0&&dm_part->part_info[i].part_visibility==1)
			{
				
				MSG (INIT, "Full download is need %x \n",i);
				retval=DM_ERR_NO_VALID_TABLE;
				return retval;
			}
		}

		pageoffset=find_empty_page_from_top(start_addr);
		//download partition used the new partition
		//write mirror at the same 2 page
		memset(page_buf,0xFF,PAGE_SIZE+64);
		*(int *)sig_buf = MPT_SIG;
		memcpy(page_buf,&sig_buf,PT_SIG_SIZE);
		memcpy(&page_buf[PT_SIG_SIZE],&new_part[0],sizeof(new_part));		
		memcpy(&page_buf[PAGE_SIZE],&sig_buf,PT_SIG_SIZE);
		pi.sequencenumber+=1;
		memcpy(&page_buf[PAGE_SIZE+PT_SIG_SIZE],&pi,PT_SIG_SIZE);
		#if 0
             for(i=0;i<8;i++)
             {
             	MSG (INIT, "%x\n",page_buf[i]);
             }	
		#endif	 
		if(pageoffset!=0xFFFF)                                                      
		{
			if((pageoffset%2)!=0)
			{
				MSG (INIT, "new_pt mirror block may destroy last time%x\n",pageoffset);
				pageoffset+=1;	
			}
			for(i=0;i<2;i++)
			{
				current_addr=start_addr+(pageoffset+i)*PAGE_SIZE;
				if(!mtk_nand_write_page_hwecc(current_addr, page_buf))
				{
					MSG (INIT, "new_pt write m first page failed %x\n",current_addr);
				}
				else
				{
					MSG (INIT, "new_pt w_mpt at %x\n",current_addr);
					//read back verify
					if((!mtk_nand_read_page_hwecc(current_addr, page_readbuf))||memcmp(page_buf,page_readbuf,PAGE_SIZE))
					{
						MSG (INIT, "new_pt read or verify first mirror page failed %x \n",current_addr);
						memcpy(page_buf,0,PT_SIG_SIZE);
						if(mtk_nand_write_page_hwecc(current_addr,page_buf))
						{
							MSG (INIT, "new_pt mark failed %x\n",current_addr);
						}		
					}
					else
					{
						MSG (INIT, "new_pt w_mpt ok %x\n",i);
						//any one success set this flag?
						pi.mirror_pt_dl=1;
					}
				}
			}
	      	}
	}
	else
	{
		MSG (INIT, "new_part_tab no pt change %x\n",i);
	}
#endif	
	retval=DM_ERR_OK;
//for test
//	retval=DM_ERR_NO_VALID_TABLE;
	return retval;
}
Ejemplo n.º 2
0
int FolderTree::GetTypeAndName(string &strType, string &strName)
{
    strType = MSG(MFolderTreeType);
    strName.Clear();
    return MODALTYPE_FINDFOLDER;
}
Ejemplo n.º 3
0
void ghost_start(const char * ghost_addr, const char * ghost_port)
{
    /* You cannot start a running ghost listener.*/
    if (ghost_run) return;

    int i; /* loop variable and temporary variable for return value */

    struct addrinfo addresses;
    struct addrinfo *result; /* store result of getaddrinfo */
    struct addrinfo *q;      /* pointer to move into *result data */
    char host_name[64];
    char port_name[64];

    memset(&addresses, 0, sizeof addresses);
    addresses.ai_family = AF_UNSPEC;   /* should handle IP v4 or v6 automatically */
    addresses.ai_socktype = SOCK_DGRAM;

    /* Get the credentials for this server. */
    i = getaddrinfo(ghost_addr, ghost_port, &addresses, &result);
    if (i != 0)
    { MSG("ERROR: [up] getaddrinfo on address %s (PORT %s) returned %s\n", ghost_addr, ghost_port, gai_strerror(i));
      exit(EXIT_FAILURE); }

    /* try to open socket for ghost listener */
    for (q=result; q!=NULL; q=q->ai_next)
    { sock_ghost = socket(q->ai_family, q->ai_socktype,q->ai_protocol);
      if (sock_ghost == -1) continue; /* try next field */
      else break; }

    /* See if the connection was a success, if not, this is a permanent failure */
    if (q == NULL)
    { MSG("ERROR: [down] failed to open socket to any of server %s addresses (port %s)\n", ghost_addr, ghost_port);
      i = 1;
      for (q=result; q!=NULL; q=q->ai_next)
      { getnameinfo(q->ai_addr, q->ai_addrlen, host_name, sizeof host_name, port_name, sizeof port_name, NI_NUMERICHOST);
        MSG("INFO: [down] result %i host:%s service:%s\n", i, host_name, port_name);
        ++i; }
      exit(EXIT_FAILURE); }

    /* connect so we can send/receive packet with the server only */
    i = connect(sock_ghost, q->ai_addr, q->ai_addrlen);
    if (i != 0) {
        MSG("ERROR: [down] connect returned %s\n", strerror(errno));
        exit(EXIT_FAILURE); }

    freeaddrinfo(result);

    /* set the circular buffer pointers to the beginning */
    ghst_bgn = 0;
    ghst_end = 0;

    /* spawn thread to manage ghost connection */
    ghost_run = true;
    i = pthread_create( &thrid_ghost, NULL, (void * (*)(void *))thread_ghost, NULL);
    if (i != 0)
    { MSG("ERROR: [main] impossible to create ghost thread\n");
      exit(EXIT_FAILURE); }

    /* We are done here, ghost thread is initialized and should be running by now. */

}
Ejemplo n.º 4
0
/*
|| Standard main
*/
int
main( int argc, char *argv[] )
{
    char           *pgmname;                /* prog name in host format  */
    char           *pgm;                    /* less any extension (.ext) */
    char            msgbuf[512];            /* message build work area   */
    FILE           *outf;
    int             rc;
    int             i;
    char            pathname[MAX_PATH];
    char           *strtok_str = NULL;

    /* Set program name */
    if ( argc > 0 )
    {
        if ( strlen(argv[0]) == 0 )
        {
            pgmname = strdup( UTILITY_NAME );
        }
        else
        {
            char path[MAX_PATH];
#if defined( _MSVC_ )
            GetModuleFileName( NULL, path, MAX_PATH );
#else
            strncpy( path, argv[0], sizeof( path ) );
#endif
            pgmname = strdup(basename(path));
#if !defined( _MSVC_ )
            strncpy( path, argv[0], sizeof(path) );
#endif
        }
    }
    else
    {
        pgmname = strdup( UTILITY_NAME );
    }

    pgm = strtok_r( strdup(pgmname), ".", &strtok_str);
    INITIALIZE_UTILITY( pgmname );

    /* Display the program identification message */
    MSGBUF( msgbuf, MSG_C( HHC02499, "I", pgm, "Extract Files from AWS, HET or FAKETAPE" ) );
    display_version (stderr, msgbuf+10, FALSE);

    /*
    || Process option switches
    */
    while( TRUE )
    {
        rc = getopt( argc, argv, "abhnsu" );
        if( rc == -1 )
        {
            break;
        }

        switch( rc )
        {
            case 'a':
                opts.flags |= O_ASCII;
                set_codepage(NULL);
            break;

            case 'h':
                usage( pgm );
                exit( 1 );
            break;

            case 'n':
                opts.flags |= O_NL;
            break;

            case 's':
                opts.flags |= O_STRIP;
            break;

            case 'u':
                opts.flags |= O_UNBLOCK;
            break;

            default:
                usage( pgm );
                exit( 1 );
            break;
        }
    }

    /*
    || Calc number of non-switch arguments
    */
    argc -= optind;

    /*
    || We must have at least the first 3 parms
    */
    if(argc < 3)
    {
        if ( argc > 1 )
            WRMSG( HHC02446, "E" );
        usage( pgm );
        exit( 1 );
    }

    hostpath( pathname, argv[ optind ], sizeof(pathname) );
    opts.ifile = strdup( pathname );
    if ( ( rc = (int)strlen( opts.ifile ) ) > 4 
      && ( rc = strcasecmp( &opts.ifile[rc-4], ".fkt" ) ) == 0 )
    {
        opts.faketape = TRUE;
    }


    hostpath( pathname, argv[ optind + 1 ], sizeof(pathname) );
    opts.ofile = strdup( pathname );

    opts.fileno = atoi( argv[ optind + 2 ] );

    if( opts.fileno == 0 || opts.fileno > 9999 )
    {
        char msgbuf[20];
        MSGBUF( msgbuf, "%d", opts.fileno );
        WRMSG( HHC02205, "E", msgbuf, "; file number must be within the range of 1 to 9999" );
        exit( 1 );
    }

    /*
    || If NL tape, then we require the DCB attributes
    */
    if( opts.flags & O_NL )
    {
        if( argc != 6 )
        {
            WRMSG( HHC02750, "E" );
            exit( 1 );
        }
    }

    /*
    || If specified, get the DCB attributes
    */
    if( argc > 3 )
    {
        /*
        || Must have only three
        */
        if( argc != 6 )
        {
            usage( pgm );
            exit( 1 );
        }

        /*
        || Lookup the specified RECFM in our table
        */
        opts.recfm = 0;
        for( i = 0 ; i < (int)VALFMCNT ; i++ )
        {
            if( strcasecmp( argv[ optind + 3 ], valfm[ i ].recfm ) == 0 )
            {
                opts.recfm = valfm[ i ].fmt;
                break;
            }
        }

        /*
        || If we didn't find a match, show the user what the valid ones are
        */
        if( opts.recfm == 0)
        {
            char msgbuf[512] = "";
            char msgbuf2[64] = "";
            char msgbuf3[16] = "";
            char msgbuf4[128] = "";

            /*
            || Dump out the valid RECFMs
            */
            MSGBUF( msgbuf, MSG( HHC02751, "I" ) );
            for( i = 0 ; i < (int)VALFMCNT ; i++ )
            {
                MSGBUF( msgbuf3, "  %-4.4s", valfm[ i ].recfm );

                if( ( ( i + 1 ) % 3 ) == 0 )
                {
                    strcat( msgbuf2, msgbuf3 );
                    MSGBUF( msgbuf4, MSG( HHC02752, "I", msgbuf2 ) );
                    strcat( msgbuf, msgbuf4 );
                    msgbuf2[0] = 0;
                }
                else
                {
                    strcat( msgbuf2, msgbuf3 );
                }
            }
            printf( "%s", msgbuf );
            exit( 1 );
        }

        /*
        || Get the record length
        */
        opts.lrecl = atoi( argv[ optind + 4 ] );

        /*
        || Get and validate the blksize
        */
        opts.blksize = atoi( argv[ optind + 5 ] );
        if( opts.blksize == 0 )
        {
            WRMSG( HHC02205, "E", "0", "; block size can't be zero" );
            exit( 1 );
        }
    }

    /*
    || Open the tape file
    */
    if ( opts.faketape )
        rc = fet_open( &opts.fetb, opts.ifile, FETOPEN_READONLY );
    else
        rc = het_open( &opts.hetb, opts.ifile, HETOPEN_READONLY );
    if( rc >= 0 )
    {
        /*
        || Get memory for the tape buffer
        */
        blkptr = malloc( HETMAX_BLOCKSIZE );
        if( blkptr != NULL )
        {
            /*
            || Open the output file
            */
            outf = fopen( opts.ofile, "wb" );
            if( outf != NULL )
            {
                /*
                || Go extract the file from the tape
                */
                rc = getfile( outf );

                /*
                || Close the output file
                */
                fclose( outf );
            }
            
            /*
            || Free the buffer memory
            */
            free( blkptr );
        }
    }
    else
    {
        if ( opts.faketape )
            WRMSG( HHC00075, "E", "fet_open()", fet_error( rc ) );
        else
            WRMSG( HHC00075, "E", "het_open()", het_error( rc ) );
    }

    /*
    || Close the tape file
    */
    if ( opts.faketape )
        fet_close( &opts.fetb );
    else
        het_close( &opts.hetb );

    return 0;
}
Ejemplo n.º 5
0
int main(int argc, char **argv)
{
    static struct sigaction sigact; /* SIGQUIT&SIGINT&SIGTERM signal handling */

    int i; /* loop and temporary variables */

    /* Parameter parsing */
    int option_index = 0;
    static struct option long_options[] = {
        {"dig", 1, 0, 0},
        {"dac", 1, 0, 0},
        {"mix", 1, 0, 0},
        {"pa", 1, 0, 0},
        {"mod", 1, 0, 0},
        {"sf", 1, 0, 0},
        {"bw", 1, 0, 0},
        {"br", 1, 0, 0},
        {"fdev", 1, 0, 0},
        {"bt", 1, 0, 0},
        {"notch", 1, 0, 0},
        {0, 0, 0, 0}
    };
    unsigned int arg_u;
    float arg_f;
    char arg_s[64];

    /* Application parameters */
    uint32_t freq_hz = DEFAULT_FREQ_HZ;
    uint8_t g_dig = DEFAULT_DIGITAL_GAIN;
    uint8_t g_dac = DEFAULT_DAC_GAIN;
    uint8_t g_mix = DEFAULT_MIXER_GAIN;
    uint8_t g_pa = DEFAULT_PA_GAIN;
    char mod[64] = DEFAULT_MODULATION;
    uint8_t sf = DEFAULT_SF;
    unsigned int bw_khz = DEFAULT_BW_KHZ;
    float br_kbps = DEFAULT_BR_KBPS;
    uint8_t fdev_khz = DEFAULT_FDEV_KHZ;
    uint8_t bt = DEFAULT_BT;
    uint32_t tx_notch_freq = DEFAULT_NOTCH_FREQ;

    int32_t offset_i, offset_q;

    /* RF configuration (TX fail if RF chain is not enabled) */
    enum lgw_radio_type_e radio_type = LGW_RADIO_TYPE_SX1257;
    struct lgw_conf_board_s boardconf;
    struct lgw_conf_rxrf_s rfconf;
    struct lgw_tx_gain_lut_s txlut;
    struct lgw_pkt_tx_s txpkt;


    /* Parse command line options */
    while ((i = getopt_long (argc, argv, "hud::f:r:", long_options, &option_index)) != -1) {
        switch (i) {
            case 'h':
                printf("~~~ Library version string~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
                printf(" %s\n", lgw_version_info());
                printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
                printf(" -f      <float>  Tx RF frequency in MHz [800:1000]\n");
                printf(" -r      <int>    Radio type (SX1255:1255, SX1257:1257)\n");
                printf(" --notch <uint>   Tx notch filter frequency in KhZ [126..250]\n");
                printf(" --dig   <uint>   Digital gain trim, [0:3]\n");
                printf("                   0:1, 1:7/8, 2:3/4, 3:1/2\n");
                printf(" --mix   <uint>   Radio Tx mixer gain trim, [0:15]\n");
                printf("                   15 corresponds to maximum gain, 1 LSB corresponds to 2dB step\n");
                printf(" --pa    <uint>   PA gain trim, [0:3]\n");
                printf(" --mod   <char>   Modulation type ['LORA','FSK','CW']\n");
                printf(" --sf    <uint>   LoRa Spreading Factor, [7:12]\n");
                printf(" --bw    <uint>   LoRa bandwidth in kHz, [125,250,500]\n");
                printf(" --br    <float>  FSK bitrate in kbps, [0.5:250]\n");
                printf(" --fdev  <uint>   FSK frequency deviation in kHz, [1:250]\n");
                printf(" --bt    <uint>   FSK gaussian filter BT trim, [0:3]\n");
                printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
                return EXIT_SUCCESS;
                break;

            case 0:
                if (strcmp(long_options[option_index].name,"dig") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || (arg_u > 3)) {
                        printf("ERROR: argument parsing of --dig argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else
                    {
                        g_dig = (uint8_t)arg_u;
                    }
                }
                else if (strcmp(long_options[option_index].name,"dac") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || (arg_u > 3)) {
                        printf("ERROR: argument parsing of --dac argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        g_dac = (uint8_t)arg_u;
                    }
                }
                else if (strcmp(long_options[option_index].name,"mix") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || (arg_u > 15)) {
                        printf("ERROR: argument parsing of --mix argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        g_mix = (uint8_t)arg_u;
                    }
                }
                else if (strcmp(long_options[option_index].name,"pa") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || (arg_u > 3)) {
                        printf("ERROR: argument parsing of --pa argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        g_pa = arg_u;
                    }
                }
                else if (strcmp(long_options[option_index].name,"mod") == 0) {
                    i = sscanf(optarg, "%s", arg_s);
                    if ((i != 1) || ((strcmp(arg_s,"LORA") != 0) && (strcmp(arg_s,"FSK") != 0)  && (strcmp(arg_s,"CW") != 0))) {
                        printf("ERROR: argument parsing of --mod argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        sprintf(mod, "%s", arg_s);
                    }
                }
                else if (strcmp(long_options[option_index].name,"sf") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || (arg_u < 7) || (arg_u > 12)) {
                        printf("ERROR: argument parsing of --sf argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        sf = (uint8_t)arg_u;
                    }
                }
                else if (strcmp(long_options[option_index].name,"bw") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || ((arg_u != 125) && (arg_u != 250) && (arg_u != 500))) {
                        printf("ERROR: argument parsing of --bw argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        bw_khz = arg_u;
                    }
                }
                else if (strcmp(long_options[option_index].name,"br") == 0) {
                    i = sscanf(optarg, "%f", &arg_f);
                    if ((i != 1) || (arg_f < 0.5) || (arg_f > 250)) {
                        printf("ERROR: argument parsing of --br argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        br_kbps = arg_f;
                    }
                }
                else if (strcmp(long_options[option_index].name,"fdev") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || (arg_u < 1) || (arg_u > 250)) {
                        printf("ERROR: argument parsing of --fdev argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        fdev_khz = (uint8_t)arg_u;
                    }
                }
                else if (strcmp(long_options[option_index].name,"bt") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || (arg_u > 3)) {
                        printf("ERROR: argument parsing of --bt argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        bt = (uint8_t)arg_u;
                    }
                }
                else if (strcmp(long_options[option_index].name,"notch") == 0) {
                    i = sscanf(optarg, "%u", &arg_u);
                    if ((i != 1) || ((arg_u < 126) || (arg_u > 250))) {
                        printf("ERROR: argument parsing of --notch argument. Use -h to print help\n");
                        return EXIT_FAILURE;
                    }
                    else {
                        tx_notch_freq = (uint32_t)arg_u * 1000U;
                    }
                }
                else {
                    printf("ERROR: argument parsing options. Use -h to print help\n");
                    return EXIT_FAILURE;
                }
                break;

        case 'f':
            i = sscanf(optarg, "%f", &arg_f);
            if ((i != 1) || (arg_f < 1)) {
                printf("ERROR: argument parsing of -f argument. Use -h to print help\n");
                return EXIT_FAILURE;
            }
            else {
                freq_hz = (uint32_t)((arg_f * 1e6) + 0.5);
            }
            break;

        case 'r':
            i = sscanf(optarg, "%u", &arg_u);
            switch (arg_u) {
                case 1255:
                    radio_type = LGW_RADIO_TYPE_SX1255;
                    break;
                case 1257:
                    radio_type = LGW_RADIO_TYPE_SX1257;
                    break;
                default:
                    printf("ERROR: argument parsing of -r argument. Use -h to print help\n");
                    return EXIT_FAILURE;
            }
            break;

        default:
            printf("ERROR: argument parsing options. Use -h to print help\n");
            return EXIT_FAILURE;
        }
    }

    /* Configure signal handling */
    sigemptyset( &sigact.sa_mask );
    sigact.sa_flags = 0;
    sigact.sa_handler = sig_handler;
    sigaction( SIGQUIT, &sigact, NULL );
    sigaction( SIGINT, &sigact, NULL );
    sigaction( SIGTERM, &sigact, NULL );

    /* Board config */
    memset(&boardconf, 0, sizeof(boardconf));
    boardconf.lorawan_public = true;
    boardconf.clksrc = 1; /* Radio B is source by default */
    lgw_board_setconf(boardconf);

    /* RF config */
    memset(&rfconf, 0, sizeof(rfconf));
    rfconf.enable = true;
    rfconf.freq_hz = freq_hz;
    rfconf.rssi_offset = DEFAULT_RSSI_OFFSET;
    rfconf.type = radio_type;
    rfconf.tx_enable = true;
    rfconf.tx_notch_freq = tx_notch_freq;
    lgw_rxrf_setconf(TX_RF_CHAIN, rfconf);

    /* Tx gain LUT */
    memset(&txlut, 0, sizeof txlut);
    txlut.size = 1;
    txlut.lut[0].dig_gain = g_dig;
    txlut.lut[0].pa_gain = g_pa;
    txlut.lut[0].dac_gain = g_dac;
    txlut.lut[0].mix_gain = g_mix;
    txlut.lut[0].rf_power = 0;
    lgw_txgain_setconf(&txlut);

    /* Start the concentrator */
    i = lgw_start();
    if (i == LGW_HAL_SUCCESS) {
        MSG("INFO: concentrator started, packet can be sent\n");
    } else {
        MSG("ERROR: failed to start the concentrator\n");
        return EXIT_FAILURE;
    }

    /* fill-up payload and parameters */
    memset(&txpkt, 0, sizeof(txpkt));
    txpkt.freq_hz = freq_hz;
    txpkt.tx_mode = IMMEDIATE;
    txpkt.rf_chain = TX_RF_CHAIN;
    txpkt.rf_power = 0;
    if (strcmp(mod, "FSK") == 0) {
        txpkt.modulation = MOD_FSK;
        txpkt.datarate = br_kbps * 1e3;
    } else {
        txpkt.modulation = MOD_LORA;
        switch (bw_khz) {
            case 125: txpkt.bandwidth = BW_125KHZ; break;
            case 250: txpkt.bandwidth = BW_250KHZ; break;
            case 500: txpkt.bandwidth = BW_500KHZ; break;
            default:
                MSG("ERROR: invalid 'bw' variable\n");
                return EXIT_FAILURE;
        }
        switch (sf) {
            case  7: txpkt.datarate = DR_LORA_SF7;  break;
            case  8: txpkt.datarate = DR_LORA_SF8;  break;
            case  9: txpkt.datarate = DR_LORA_SF9;  break;
            case 10: txpkt.datarate = DR_LORA_SF10; break;
            case 11: txpkt.datarate = DR_LORA_SF11; break;
            case 12: txpkt.datarate = DR_LORA_SF12; break;
            default:
                MSG("ERROR: invalid 'sf' variable\n");
                return EXIT_FAILURE;
        }
    }
    txpkt.coderate = CR_LORA_4_5;
    txpkt.f_dev = fdev_khz;
    txpkt.preamble = 65535;
    txpkt.invert_pol = false;
    txpkt.no_crc = true;
    txpkt.no_header = true;
    txpkt.size = 1;
    txpkt.payload[0] = 0;

    /* Overwrite settings */
    lgw_reg_w(LGW_TX_MODE, 1); /* Tx continuous */
    lgw_reg_w(LGW_FSK_TX_GAUSSIAN_SELECT_BT, bt);
    if (strcmp(mod, "CW") == 0) {
        /* Enable signal generator with DC */
        lgw_reg_w(LGW_SIG_GEN_FREQ, 0);
        lgw_reg_w(LGW_SIG_GEN_EN, 1);
        lgw_reg_w(LGW_TX_OFFSET_I, 0);
        lgw_reg_w(LGW_TX_OFFSET_Q, 0);
    }

    /* Send packet */
    i = lgw_send(txpkt);

    /* Recap all settings */
    printf("SX1301 library version: %s\n", lgw_version_info());
    if (strcmp(mod, "LORA") == 0) {
        printf("Modulation: LORA SF:%d BW:%d kHz\n", sf, bw_khz);
    }
    else if (strcmp(mod, "FSK") == 0) {
        printf("Modulation: FSK BR:%3.3f kbps FDEV:%d kHz BT:%d\n", br_kbps, fdev_khz, bt);
    }
    else if (strcmp(mod, "CW") == 0) {
        printf("Modulation: CW\n");
    }
    switch(rfconf.type) {
        case LGW_RADIO_TYPE_SX1255:
            printf("Radio Type: SX1255\n");
            break;
        case LGW_RADIO_TYPE_SX1257:
            printf("Radio Type: SX1257\n");
            break;
        default:
            printf("ERROR: undefined radio type\n");
            break;
    }
    printf("Frequency: %4.3f MHz\n", freq_hz/1e6);
    printf("TX Gains: Digital:%d DAC:%d Mixer:%d PA:%d\n", g_dig, g_dac, g_mix, g_pa);
    if (strcmp(mod, "CW") != 0) {
        lgw_reg_r(LGW_TX_OFFSET_I, &offset_i);
        lgw_reg_r(LGW_TX_OFFSET_Q, &offset_q);
        printf("Calibrated DC offsets: I:%d Q:%d\n", offset_i, offset_q);
    }

    /* waiting for user input */
    while ((quit_sig != 1) && (exit_sig != 1)) {
        wait_ms(100);
    }

    /* clean up before leaving */
    lgw_stop();

    return 0;
}
Ejemplo n.º 6
0
int FileViewer::ProcessKey(int Key)
{
	if (RedrawTitle && (((unsigned int)Key & 0x00ffffff) < KEY_END_FKEY || IsInternalKeyReal((unsigned int)Key & 0x00ffffff)))
		ShowConsoleTitle();

	if (Key!=KEY_F3 && Key!=KEY_IDLE)
		F3KeyOnly=false;

	switch (Key)
	{
#if 0
			/* $ 30.05.2003 SVS
			   Фича :-) Shift-F4 в редакторе/вьювере позволяет открывать другой редактор/вьювер
			   Пока закомментим
			*/
		case KEY_SHIFTF4:
		{
			if (!Opt.OnlyEditorViewerUsed)
				CtrlObject->Cp()->ActivePanel->ProcessKey(Key);

			return TRUE;
		}
#endif
		/* $ 22.07.2000 tran
		   + выход по ctrl-f10 с установкой курсора на файл */
		case KEY_CTRLF10:
		case KEY_RCTRLF10:
		{
			if (View.isTemporary())
			{
				return TRUE;
			}

			SaveScreen Sc;
			string strFileName;
			View.GetFileName(strFileName);
			CtrlObject->Cp()->GoToFile(strFileName);
			RedrawTitle = TRUE;
			return (TRUE);
		}
		// $ 15.07.2000 tran + CtrlB switch KeyBar
		case KEY_CTRLB:
		case KEY_RCTRLB:
			Opt.ViOpt.ShowKeyBar=!Opt.ViOpt.ShowKeyBar;

			if (Opt.ViOpt.ShowKeyBar)
				ViewKeyBar.Show();
			else
				ViewKeyBar.Hide0(); // 0 mean - Don't purge saved screen

			Show();
			KeyBarVisible = Opt.ViOpt.ShowKeyBar;
			return (TRUE);
		case KEY_CTRLSHIFTB:
		case KEY_RCTRLSHIFTB:
		{
			Opt.ViOpt.ShowTitleBar=!Opt.ViOpt.ShowTitleBar;
			TitleBarVisible = Opt.ViOpt.ShowTitleBar;
			Show();
			return (TRUE);
		}
		case KEY_CTRLO:
		case KEY_RCTRLO:

			if (!Opt.OnlyEditorViewerUsed)
			{
				if (FrameManager->ShowBackground())
				{
					SetCursorType(FALSE,0);
					WaitKey();
					FrameManager->RefreshFrame();
				}
			}

			return TRUE;
		case KEY_F3:
		case KEY_NUMPAD5:  case KEY_SHIFTNUMPAD5:

			if (F3KeyOnly)
				return TRUE;

		case KEY_ESC:
		case KEY_F10:
			FrameManager->DeleteFrame();
			return TRUE;
		case KEY_F6:

			if (!DisableEdit)
			{
				UINT cp=View.VM.CodePage;
				string strViewFileName;
				View.GetFileName(strViewFileName);
				File Edit;
				while(!Edit.Open(strViewFileName, FILE_READ_DATA, FILE_SHARE_READ|(Opt.EdOpt.EditOpenedForWrite?FILE_SHARE_WRITE:0), nullptr, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN))
				{
					if(!OperationFailed(strViewFileName, MEditTitle, MSG(MEditCannotOpen), false))
						continue;
					else
						return TRUE;
				}
				Edit.Close();
				__int64 FilePos=View.GetFilePos();
				DWORD flags = (GetCanLoseFocus()?FFILEEDIT_ENABLEF6:0)|(SaveToSaveAs?FFILEEDIT_SAVETOSAVEAS:0)|(DisableHistory?FFILEEDIT_DISABLEHISTORY:0);
				FileEditor *ShellEditor = new FileEditor(
					strViewFileName, cp, flags, -2,
					static_cast<int>(FilePos), // TODO: Editor StartChar should be __int64
					str_title.IsEmpty() ? nullptr: &str_title,
					-1,-1, -1, -1, delete_on_close );
				ShellEditor->SetEnableF6(TRUE);
				/* $ 07.05.2001 DJ сохраняем NamesList */
				ShellEditor->SetNamesList(View.GetNamesList());

				// Если переключаемся в редактор, то удалять файл уже не нужно
				SetTempViewName(L"");
				SetExitCode(0);

				FrameManager->DeleteFrame(this); // Insert уже есть внутри конструктора
				ShowTime(2);
			}

			return TRUE;

		case KEY_ALTSHIFTF9:
		case KEY_RALTSHIFTF9:
			// Работа с локальной копией ViewerOptions
			ViewerConfig(View.ViOpt, true);

			if (Opt.ViOpt.ShowKeyBar)
				ViewKeyBar.Show();

			View.Show();
			return TRUE;
		case KEY_ALTF11:
		case KEY_RALTF11:
			if (GetCanLoseFocus())
				CtrlObject->CmdLine->ShowViewEditHistory();

			return TRUE;
		default:
//      Этот кусок - на будущее (по аналогии с редактором :-)
//      if (CtrlObject->Macro.IsExecuting() || !View.ProcessViewerInput(&ReadRec))
		{
			/* $ 22.03.2001 SVS
			   Это помогло от залипания :-)
			*/
			if (!CtrlObject->Macro.IsExecuting())
				if (Opt.ViOpt.ShowKeyBar)
					ViewKeyBar.Show();

			if (!ViewKeyBar.ProcessKey(Key))
				return(View.ProcessKey(Key));
		}
		return TRUE;
	}
}
Ejemplo n.º 7
0
int main(int argc, char **argv) {


  int i = 0;
  thread_data_t *td_arr; 
  GASNET_Safe(gasnet_init(&argc, &argv));
  GASNET_Safe(gasnet_attach(NULL, 0, TEST_SEGSZ_REQUEST, TEST_MINHEAPOFFSET));


  
  mynode = gasnet_mynode();
  nodes = gasnet_nodes();

  if (argc > 1) iters = atoi(argv[1]);
  if (!iters) iters = 10000;
#if GASNET_PAR
  test_init("testteambarrier", 2, "(iters) (threadcount) (test sections)");
  if (argc > 2) {
    threads_per_node = atoi(argv[2]);
  } else {
    if (gasnett_getenv_yesno_withdefault("GASNET_TEST_POLITE_SYNC",0)) {
      /* May overcommit only if somebody already expected it */
      threads_per_node = gasnett_cpu_count();
    } else {
      threads_per_node = gasnett_cpu_count() / TEST_LOCALPROCS();
    } 
    threads_per_node = MIN(threads_per_node, 8);
    threads_per_node = test_thread_limit(threads_per_node);
    threads_per_node = MAX(threads_per_node, 1);
  } 
  if (threads_per_node > TEST_MAXTHREADS || threads_per_node < 1) {
    printf("ERROR: Threads must be between 1 and %d\n", TEST_MAXTHREADS);
    exit(EXIT_FAILURE);
  }
  if (argc > 3) TEST_SECTION_PARSE(argv[3]);
  if (argc > 4) test_usage();
#else
  test_init("testteambarrier", 1, "(iters) (test sections)");
  threads_per_node = 1;
  if (argc > 3) test_usage();
  if (argc > 2) TEST_SECTION_PARSE(argv[2]);
#endif  
  TEST_SET_WAITMODE(threads_per_node);

  td_arr = (thread_data_t*) test_malloc(sizeof(thread_data_t)*threads_per_node);
  for(i=0; i<threads_per_node; i++) {
    td_arr[i].my_local_thread = i;
    td_arr[i].mythread = mynode*threads_per_node+i;
  }
#if GASNET_PAR
  test_createandjoin_pthreads(threads_per_node, &thread_main, td_arr, sizeof(thread_data_t));
#else
  thread_main(&td_arr[0]);
#endif
  test_free(td_arr);
  

  gasnet_coll_barrier_notify(GASNET_TEAM_ALL, 0, GASNET_BARRIERFLAG_ANONYMOUS); 
  GASNET_Safe(gasnet_coll_barrier_wait(GASNET_TEAM_ALL, 0, GASNET_BARRIERFLAG_ANONYMOUS));
  MSG("done.");
  gasnet_exit(0);
  return 0;
}
static int femu_hw_WritePageWithLayout(uffs_Device *dev, u32 block, u32 page,
							const u8 *data, int data_len, const u8 *ecc, const uffs_TagStore *ts)
{
	int written;
	int abs_page;
	int full_page_size;
	uffs_FileEmu *emu;
	struct uffs_StorageAttrSt *attr = dev->attr;
	u8 spare[UFFS_MAX_SPARE_SIZE];
	u8 ecc_buf[UFFS_MAX_ECC_SIZE];
	int spare_len;


	emu = (uffs_FileEmu *)(dev->attr->_private);

	if (!emu || !(emu->fp)) {
		goto err;
	}

	abs_page = attr->pages_per_block * block + page;
	full_page_size = attr->page_data_size + attr->spare_size;

	if (data && data_len > 0) {
		if (data_len > attr->page_data_size)
			goto err;

		emu->em_monitor_page[abs_page]++;
		if (emu->em_monitor_page[abs_page] > PAGE_DATA_WRITE_COUNT_LIMIT) {
			MSG("Warrning: block %d page %d exceed it's maximum write time!", block, page);
			goto err;
		}
		
		fseek(emu->fp, abs_page * full_page_size, SEEK_SET);

		written = fwrite(data, 1, data_len, emu->fp);
		
		if (written != data_len) {
			MSG("write page I/O error ?");
			goto err;
		}

		dev->st.page_write_count++;
		dev->st.io_write += written;

	}

	if (ts) {

		emu->em_monitor_spare[abs_page]++;
		if (emu->em_monitor_spare[abs_page] > PAGE_SPARE_WRITE_COUNT_LIMIT) {
			MSG("Warrning: block %d page %d (spare) exceed it's maximum write time!", block, page);
			goto err;
		}

		if (!uffs_Assert(data != NULL, "BUG: Write spare without data ?"))
			goto err;

		uffs_EccMake(data, data_len, ecc_buf);
		uffs_FlashMakeSpare(dev, ts, ecc_buf, spare);
		spare_len = dev->mem.spare_data_size;
		
		fseek(emu->fp, abs_page * full_page_size + attr->page_data_size, SEEK_SET);
		written = fwrite(spare, 1, spare_len, emu->fp);
		if (written != spare_len) {
			MSG("write spare I/O error ?");
			goto err;
		}

		dev->st.spare_write_count++;
		dev->st.io_write += written;
	}

	if (data == NULL && ts == NULL) {
		// mark bad block
		fseek(emu->fp, abs_page * full_page_size + attr->page_data_size + attr->block_status_offs, SEEK_SET);
		written = fwrite("\0", 1, 1, emu->fp);
		if (written != 1) {
			MSG("write bad block mark I/O error ?");
			goto err;
		}
		dev->st.io_write++;
	}

	fflush(emu->fp);
	return UFFS_FLASH_NO_ERR;
err:
	fflush(emu->fp);
	return UFFS_FLASH_IO_ERR;
}
Ejemplo n.º 9
0
static bool SelectLanguage(bool HelpLanguage)
{
	const wchar_t *Title,*Mask;
	StringOption *strDest;

	if (HelpLanguage)
	{
		Title=MSG(MHelpLangTitle);
		Mask=Global->HelpFileMask;
		strDest=&Global->Opt->strHelpLanguage;
	}
	else
	{
		Title=MSG(MLangTitle);
		Mask=LangFileMask;
		strDest=&Global->Opt->strLanguage;
	}

	VMenu2 LangMenu(Title,nullptr,0,ScrY-4);
	LangMenu.SetFlags(VMENU_WRAPMODE);
	LangMenu.SetPosition(ScrX/2-8+5*HelpLanguage,ScrY/2-4+2*HelpLanguage,0,0);
	string strFullName;
	api::FAR_FIND_DATA FindData;
	ScanTree ScTree(false, false);
	ScTree.SetFindPath(Global->g_strFarPath, Mask);

	while (ScTree.GetNextName(&FindData,strFullName))
	{
		api::File LangFile;
		if (!LangFile.Open(strFullName, FILE_READ_DATA, FILE_SHARE_READ, nullptr, OPEN_EXISTING))
			continue;

		uintptr_t nCodePage=CP_OEMCP;
		GetFileFormat(LangFile, nCodePage, nullptr, false);
		string strLangName, strLangDescr;

		if (GetLangParam(LangFile,L"Language",&strLangName,&strLangDescr,nCodePage))
		{
			string strEntryName;

			if (!HelpLanguage || (!GetLangParam(LangFile,L"PluginContents",&strEntryName,nullptr,nCodePage) &&
			                      !GetLangParam(LangFile,L"DocumentContents",&strEntryName,nullptr,nCodePage)))
			{
				MenuItemEx LangMenuItem(str_printf(L"%.40s", !strLangDescr.empty() ? strLangDescr.data():strLangName.data()));

				/* $ 01.08.2001 SVS
				   Не допускаем дубликатов!
				   Если в каталог с ФАРом положить еще один HLF с одноименным
				   языком, то... фигня получается при выборе языка.
				*/
				if (LangMenu.FindItem(0,LangMenuItem.strName,LIFIND_EXACTMATCH) == -1)
				{
					LangMenuItem.SetSelect(!StrCmpI(*strDest, strLangName));
					LangMenu.SetUserData(strLangName.data(), (strLangName.size()+1)*sizeof(wchar_t), LangMenu.AddItem(LangMenuItem));
				}
			}
		}
	}

	LangMenu.AssignHighlights(FALSE);
	LangMenu.Run();

	if (LangMenu.GetExitCode()<0)
		return false;

	*strDest = static_cast<const wchar_t*>(LangMenu.GetUserData(nullptr, 0));
	return true;
}
Ejemplo n.º 10
0
void list_version(void)
{
  int i;
  int first;
  char *s = "";

  // When adding features here, don't forget to update the list of
  // internal variables in eval.c!
  MSG(longVersion);

  // Print the list of patch numbers if there is at least one.
  // Print a range when patches are consecutive: "1-10, 12, 15-40, 42-45"
  if (included_patches[0] != 0) {
    MSG_PUTS(_("\nIncluded patches: "));
    first = -1;

    // find last one
    for (i = 0; included_patches[i] != 0; ++i) {}

    while (--i >= 0) {
      if (first < 0) {
        first = included_patches[i];
      }

      if ((i == 0) || (included_patches[i - 1] != included_patches[i] + 1)) {
        MSG_PUTS(s);
        s = ", ";
        msg_outnum((long)first);

        if (first != included_patches[i]) {
          MSG_PUTS("-");
          msg_outnum((long)included_patches[i]);
        }
        first = -1;
      }
    }
  }

  // Print the list of extra patch descriptions if there is at least one.
  if (extra_patches[0] != NULL) {
    MSG_PUTS(_("\nExtra patches: "));
    s = "";

    for (i = 0; extra_patches[i] != NULL; ++i) {
      MSG_PUTS(s);
      s = ", ";
      MSG_PUTS(extra_patches[i]);
    }
  }

#ifdef MODIFIED_BY
  MSG_PUTS("\n");
  MSG_PUTS(_("Modified by "));
  MSG_PUTS(MODIFIED_BY);
#endif  // ifdef MODIFIED_BY

#ifdef HAVE_PATHDEF

  if ((*compiled_user != NUL) || (*compiled_sys != NUL)) {
    MSG_PUTS(_("\nCompiled "));

    if (*compiled_user != NUL) {
      MSG_PUTS(_("by "));
      MSG_PUTS(compiled_user);
    }

    if (*compiled_sys != NUL) {
      MSG_PUTS("@");
      MSG_PUTS(compiled_sys);
    }
  }
#endif  // ifdef HAVE_PATHDEF

  MSG_PUTS(_("\nHuge version "));
  MSG_PUTS(_("without GUI."));
  version_msg(_("  Features included (+) or not (-):\n"));

  list_features();

#ifdef SYS_VIMRC_FILE
  version_msg(_("   system vimrc file: \""));
  version_msg(SYS_VIMRC_FILE);
  version_msg("\"\n");
#endif  // ifdef SYS_VIMRC_FILE
#ifdef USR_VIMRC_FILE
  version_msg(_("     user vimrc file: \""));
  version_msg(USR_VIMRC_FILE);
  version_msg("\"\n");
#endif  // ifdef USR_VIMRC_FILE
#ifdef USR_VIMRC_FILE2
  version_msg(_(" 2nd user vimrc file: \""));
  version_msg(USR_VIMRC_FILE2);
  version_msg("\"\n");
#endif  // ifdef USR_VIMRC_FILE2
#ifdef USR_VIMRC_FILE3
  version_msg(_(" 3rd user vimrc file: \""));
  version_msg(USR_VIMRC_FILE3);
  version_msg("\"\n");
#endif  // ifdef USR_VIMRC_FILE3
#ifdef USR_EXRC_FILE
  version_msg(_("      user exrc file: \""));
  version_msg(USR_EXRC_FILE);
  version_msg("\"\n");
#endif  // ifdef USR_EXRC_FILE
#ifdef USR_EXRC_FILE2
  version_msg(_("  2nd user exrc file: \""));
  version_msg(USR_EXRC_FILE2);
  version_msg("\"\n");
#endif  // ifdef USR_EXRC_FILE2
#ifdef HAVE_PATHDEF

  if (*default_vim_dir != NUL) {
    version_msg(_("  fall-back for $VIM: \""));
    version_msg((char *)default_vim_dir);
    version_msg("\"\n");
  }

  if (*default_vimruntime_dir != NUL) {
    version_msg(_(" f-b for $VIMRUNTIME: \""));
    version_msg((char *)default_vimruntime_dir);
    version_msg("\"\n");
  }
  version_msg(_("Compilation: "));
  version_msg((char *)all_cflags);
  version_msg("\n");
  version_msg(_("Linking: "));
  version_msg((char *)all_lflags);
#endif  // ifdef HAVE_PATHDEF
#ifdef DEBUG
  version_msg("\n");
  version_msg(_("  DEBUG BUILD"));
#endif  // ifdef DEBUG
}
static URET femu_hw_ReadPageWithLayout(uffs_Device *dev, u32 block, u32 page, u8* data, int data_len, u8 *ecc,
									uffs_TagStore *ts, u8 *ecc_store)
{
	int nread;
	uffs_FileEmu *emu;
	int abs_page;
	int full_page_size;
	struct uffs_StorageAttrSt *attr = dev->attr;
	unsigned char status;
	u8 spare[UFFS_MAX_SPARE_SIZE];
	int spare_len;

	emu = (uffs_FileEmu *)(dev->attr->_private);

	if (!emu || !(emu->fp)) {
		goto err;
	}

	abs_page = attr->pages_per_block * block + page;
	full_page_size = attr->page_data_size + attr->spare_size;

	if (data && data_len > 0) {
		if (data_len > attr->page_data_size)
			goto err;

		fseek(emu->fp, abs_page * full_page_size, SEEK_SET);
		nread = fread(data, 1, data_len, emu->fp);

		if (nread != data_len) {
			MSG("read page I/O error ?");
			goto err;
		}
		dev->st.io_read += nread;
		dev->st.page_read_count++;

		if (ecc) {
			// calculate ECC for data
			uffs_EccMake(data, data_len, ecc);
		}
	}

	if (ts) {

		spare_len = dev->mem.spare_data_size;
		fseek(emu->fp, abs_page * full_page_size + attr->page_data_size, SEEK_SET);
		nread = fread(spare, 1, spare_len, emu->fp);

		if (nread != spare_len) {
			MSG("read page spare I/O error ?");
			goto err;
		}

		// unload ts and ecc from spare
		uffs_FlashUnloadSpare(dev, spare, ts, ecc_store);

		dev->st.io_read += nread;
		dev->st.spare_read_count++;
	}

	if (data == NULL && ts == NULL) {
		// read bad block mark
		fseek(emu->fp, abs_page * full_page_size + attr->page_data_size + attr->block_status_offs, SEEK_SET);
		nread = fread(&status, 1, 1, emu->fp);

		if (nread != 1) {
			MSG("read badblock mark I/O error ?");
			goto err;
		}
		dev->st.io_read++;

		return status == 0xFF ? UFFS_FLASH_NO_ERR : UFFS_FLASH_BAD_BLK;
	}

	return UFFS_FLASH_NO_ERR;
err:
	return UFFS_FLASH_IO_ERR;
}
Ejemplo n.º 12
0
void Text(LNGID MsgId)
{
    Text(MSG(MsgId));
}
Ejemplo n.º 13
0
/* Retrieve preferences from the Preferences database */
void ReadPrefs( void )
{
    Int16   version;
    Int16   oldVersion;
    UInt16  prefSize;
    UInt16  oldPrefSize;

    ASSERT( ViewerPrefID != ViewerPrefSearchStringID );

    /* if not a test version remove preferences with ID 0 */
    if ( ViewerPrefID != 0 )
        RemovePref( 0 );

    MemSet( &pref, sizeof( Preferences ), 0 );

    /* if no preference found or the found preference has a "bad" size
       and there is no preference using an old (incompatible) format,
       then initialize a new preference structure */
    prefSize    = 0;
    version     = PrefGetAppPreferences( (UInt32) ViewerAppID,
                    (UInt16) ViewerPrefID, NULL, &prefSize, true);
    if ( version == noPreferenceFound || sizeof( Preferences ) < prefSize ) {
        MSG( _( "Version = %d, prefSize = %u\n", version, prefSize ) );
        oldPrefSize = 0;
        oldVersion  = PrefGetAppPreferences( (UInt32) ViewerAppID,
                        (UInt16) ViewerOldPrefID, NULL, &oldPrefSize, true);
        if ( oldVersion == noPreferenceFound ) {
            MSG( "No old preferences found\n" );

            pref.column.date                = SHOW;
            pref.column.size                = SHOW;
            pref.column.type                = SHOW;
            pref.strikethrough              = false;
            pref.defaultStrikethrough       = false;
            pref.multipleSelect             = true;
            pref.hardKeys                   = false;
            pref.arrowKeys                  = false;
            pref.searchFlags                = 0;
            pref.toolbar                    = TOOLBAR_TOP;
            pref.lastForm                   = frmLibrary;
            pref.scrollbar                  = SCROLLBAR_RIGHT;
            pref.controlMode                = MODE1;
            pref.screenDepth                = 0;
            pref.searchEntries              = 0;
            pref.categories                 = dmAllCategoriesAdvanced;
            pref.cardNo                     = 0;
            pref.toolbarButton              = 0;
            pref.filterMode                 = FILTER_OR;
            pref.fontModeMain               = FONT_DEFAULT;
            pref.underlineMode              = false;
            pref.defaultUnderlineMode       = false;
            pref.sortType                   = SORT_NAME;
            pref.sortOrder                  = SORTORDER_ASC;
            pref.autoscrollEnabled          = false;
            pref.autoscrollInterval         = 0;
            pref.autoscrollLastScrollTime   = 0;
            pref.autoscrollJump             = 1;
            pref.autoscrollMode             = AUTOSCROLL_PIXELS;
            pref.autoscrollDir              = AUTOSCROLL_DOWN;
            pref.autoscrollStayOn           = false;
            pref.location                   = RAM;
            pref.gestures                   = true;
            pref.gestMode[ GESTURES_UP ]    = SELECT_GO_TO_TOP;
            pref.gestMode[ GESTURES_RIGHT ] = SELECT_GO_FORWARD;
            pref.gestMode[ GESTURES_DOWN ]  = SELECT_GO_TO_BOTTOM;
            pref.gestMode[ GESTURES_LEFT ]  = SELECT_GO_BACK;
            pref.gestMode[ GESTURES_TAP ]   = SELECT_GO_HOME;
            pref.syncPolicy                 = SYNC_AUTOMATIC;
            pref.fontModeLibrary            = FONT_DEFAULT;
            pref.categoryStyle              = CATEGORY_ADVANCED;
            pref.hardcopyAction             = HARDCOPY_DIALOG;
            pref.hardcopyRange              = HARDCOPY_INVIEW;
            pref.hardcopyLink               = HARDCOPY_ATBOTTOM;
            pref.lineSpacing                = -MINIMAL_LINE_SPACING;
            pref.paragraphSpacing           = DEFAULT_PARAGRAPH_SPACING;
            pref.searchMode                 = SEARCH_IN_ONE_PAGE;
            pref.enableSoftHyphens          = true;
            pref.defaultEnableSoftHyphens   = true;
            pref.indicateOpened             = false;
            pref.individualDocumentLayout   = false;
            pref.individualDocumentFonts    = false;
            pref.individualDocumentColor    = false;
            pref.individualDocumentLookup   = false;
            pref.forceDefaultColors         = false;
            pref.defaultForceDefaultColors  = false;
            pref.savedToolbar               = TOOLBAR_TOP;
            pref.savedScrollbar             = SCROLLBAR_RIGHT;
            pref.savedSilkscreen            = DIA_STATE_MIN;
            pref.pageControlsLink           = false;
            pref.defaultPageControlsLink    = false;
            pref.forceAlign                 = FORCE_ALIGN_NONE;
            pref.defaultForceAlign          = FORCE_ALIGN_NONE;
            pref.joinUpAllRecords           = false;
            pref.rotate                     = ROTATE_ZERO;
            pref.defaultRotate              = ROTATE_ZERO;
            pref.defaultLineSpacing         = pref.lineSpacing;
            pref.defaultParagraphSpacing    = pref.paragraphSpacing;
            pref.defaultFontModeMain        = pref.fontModeMain;
            pref.selectedWordAction         = SELECT_WORD_SEARCH_FORM;
            pref.defaultSelectedWordAction  = SELECT_WORD_SEARCH_FORM;
            pref.selectWordTap              = SELECT_WORD_TAP_NONE;
            pref.defaultSelectWordTap       = SELECT_WORD_TAP_NONE;
            pref.useDateTime                = false;
            pref.searchXlit                 = 0;
            pref.rtl                        = false;
            pref.defaultRTL                 = false;
            pref.enableMargins              = true;
            pref.defaultEnableMargins       = true;
            pref.noAnnotationsInBookmarkList  = false;
            pref.alwaysDeleteAnnotations      = false;

            StrCopy( pref.docName, "" );
            StrCopy( pref.mainUserFontName, "" );
            StrCopy( pref.libraryUserFontName, "" );
            StrCopy( pref.defaultMainUserFontName, pref.mainUserFontName );

            MemSet( &pref.select, sizeof( pref.select ), SELECT_NONE );
            MemSet( &pref.hwMode, sizeof( pref.hwMode ), SELECT_NONE );

            pref.arrowKeys                         = true;
            pref.arrowMode[ UP_ARROW ]             = SELECT_FULL_PAGE_UP;
            pref.arrowMode[ DOWN_ARROW ]           = SELECT_FULL_PAGE_DOWN;
            pref.arrowMode[ LEFT_ARROW ]           = SELECT_GO_BACK;
            pref.arrowMode[ RIGHT_ARROW ]          = SELECT_GO_FORWARD;
            pref.arrowMode[ SELECT_ARROW ]         = SELECT_GO_HOME;

            MemSet( &pref.jogMode, sizeof( pref.jogMode ), SELECT_NONE );

            if ( JogdialType() != noJogdial ) {
                pref.jogEnabled                    = true;
                pref.jogMode[ JOGEVENTS_UP ]       = SELECT_HALF_PAGE_UP;
                pref.jogMode[ JOGEVENTS_DOWN ]     = SELECT_HALF_PAGE_DOWN;
                pref.jogMode[ JOGEVENTS_PUSH ]     = SELECT_GO_FORWARD;
                pref.jogMode[ JOGEVENTS_PUSHUP ]   = SELECT_FULL_PAGE_UP;
                pref.jogMode[ JOGEVENTS_PUSHDOWN ] = SELECT_FULL_PAGE_DOWN;
                pref.jogMode[ JOGEVENTS_BACK ]     = SELECT_GO_BACK;
            }

            RemovePref( ViewerPrefSearchStringID );
            RemovePref( ViewerPrefID );
        }
        else {
            /* we found a preference structure using an old (incompatible) 
               format; convert it to the new format */
            OldPreferences old;

            MemSet( &old, sizeof( OldPreferences ), 0 );

            oldVersion = PrefGetAppPreferences( (UInt32) ViewerAppID,
                            (UInt16) ViewerOldPrefID, &old, &oldPrefSize,
                            true);
            MSG( _( "Old version = %d, oldPrefSize = %u\n", oldVersion,
                    oldPrefSize ) );

            /* if we found an older version of the old preference
               format we add default values for the new items */
            if ( oldVersion < 2 ) {
                old.column.type                = SHOW;
                old.fontModeLibrary            = FONT_DEFAULT;
                old.categoryStyle              = CATEGORY_ADVANCED;
                old.hardcopyAction             = HARDCOPY_DIALOG;
                old.hardcopyRange              = HARDCOPY_INVIEW;
                old.hardcopyLink               = HARDCOPY_ATBOTTOM;
                old.searchMode                 = SEARCH_IN_ONE_PAGE;
                old.enableSoftHyphens          = true;
                old.lineSpacing                = -MINIMAL_LINE_SPACING;
                old.paragraphSpacing           = DEFAULT_PARAGRAPH_SPACING;

                MemSet( &old.jogMode, sizeof( old.jogMode ), SELECT_NONE );

                if ( JogdialType() != noJogdial ) {
                    old.jogEnabled = true;
                    old.jogMode[ JOGEVENTS_UP ]       = SELECT_HALF_PAGE_UP;
                    old.jogMode[ JOGEVENTS_DOWN ]     = SELECT_HALF_PAGE_DOWN;
                    old.jogMode[ JOGEVENTS_PUSH ]     = SELECT_GO_FORWARD;
                    old.jogMode[ JOGEVENTS_PUSHUP ]   = SELECT_FULL_PAGE_UP;
                    old.jogMode[ JOGEVENTS_PUSHDOWN ] = SELECT_FULL_PAGE_DOWN;
                    old.jogMode[ JOGEVENTS_BACK ]     = SELECT_GO_BACK;
                }
            }
            if ( version < 3 ) {
                old.indicateOpened             = false;
                old.individualDocumentFonts    = false;
                old.forceDefaultColors         = false;
                old.savedToolbar               = TOOLBAR_TOP;
                old.savedScrollbar             = SCROLLBAR_RIGHT;
                old.savedSilkscreen            = DIA_STATE_MIN;
                old.pageControlsLink           = false;
                old.forceAlign                 = FORCE_ALIGN_NONE;
                old.joinUpAllRecords           = false;
                old.rotate                     = ROTATE_ZERO;
                old.defaultRotate              = ROTATE_ZERO;
                old.defaultLineSpacing         = old.lineSpacing;
                old.defaultParagraphSpacing    = old.paragraphSpacing;
                old.defaultFontModeMain        = old.fontModeMain;
                old.selectedWordAction         = SELECT_WORD_SEARCH_FORM;
                old.selectWordTap              = SELECT_WORD_TAP_NONE;
                old.useDateTime                = false;
                old.searchXlit                 = 0;

                StrCopy( old.mainUserFontName, "" );
                StrCopy( old.libraryUserFontName, "" );
                StrCopy( old.defaultMainUserFontName, old.mainUserFontName );
            }

            pref.column                         = old.column;
            pref.strikethrough                  = old.strikethrough;
            pref.multipleSelect                 = old.multipleSelect;
            pref.searchFlags                    = old.searchFlags;
            pref.toolbar                        = old.toolbar;
            pref.lastForm                       = old.lastForm;
            pref.scrollbar                      = old.scrollbar;
            pref.controlMode                    = old.controlMode;
            pref.screenDepth                    = old.screenDepth;
            pref.searchEntries                  = old.searchEntries;
            pref.categories                     = old.categories;
            pref.cardNo                         = old.cardNo;
            pref.toolbarButton                  = old.toolbarButton;
            pref.filterMode                     = old.filterMode;
            pref.fontModeMain                   = old.fontModeMain;
            pref.underlineMode                  = old.underlineMode;
            pref.sortType                       = old.sortType;
            pref.sortOrder                      = old.sortOrder;
            pref.autoscrollEnabled              = old.autoscrollEnabled;
            pref.autoscrollInterval             = old.autoscrollInterval;
            pref.autoscrollLastScrollTime       = old.autoscrollLastScrollTime;
            pref.autoscrollJump                 = old.autoscrollJump;
            pref.autoscrollMode                 = old.autoscrollMode;
            pref.autoscrollDir                  = old.autoscrollDir;
            pref.autoscrollStayOn               = old.autoscrollStayOn;
            pref.location                       = old.location;
            pref.syncPolicy                     = old.syncPolicy;
            pref.fontModeLibrary                = old.fontModeLibrary;
            pref.categoryStyle                  = old.categoryStyle;
            pref.hardcopyAction                 = old.hardcopyAction;
            pref.hardcopyRange                  = old.hardcopyRange;
            pref.hardcopyLink                   = old.hardcopyLink;
            pref.searchMode                     = old.searchMode;
            pref.enableSoftHyphens              = old.enableSoftHyphens;
            pref.lineSpacing                    = old.lineSpacing;
            pref.paragraphSpacing               = old.paragraphSpacing;
            pref.indicateOpened                 = old.indicateOpened;
            pref.individualDocumentFonts        = old.individualDocumentFonts;
            pref.forceDefaultColors             = old.forceDefaultColors;
            pref.savedToolbar                   = old.savedToolbar;
            pref.savedScrollbar                 = old.savedScrollbar;
            pref.savedSilkscreen                = old.savedSilkscreen;
            pref.pageControlsLink               = old.pageControlsLink;
            pref.forceAlign                     = old.forceAlign;
            pref.joinUpAllRecords               = old.joinUpAllRecords;
            pref.rotate                         = old.rotate;
            pref.defaultRotate                  = old.defaultRotate;
            pref.defaultLineSpacing             = old.defaultLineSpacing;
            pref.defaultParagraphSpacing        = old.defaultParagraphSpacing;
            pref.defaultFontModeMain            = old.defaultFontModeMain;
            pref.selectedWordAction             = old.selectedWordAction;
            pref.selectWordTap                  = old.selectWordTap;
            pref.useDateTime                    = old.useDateTime;
            pref.searchXlit                     = old.searchXlit;
            pref.hardKeys                       = old.hardKeys;
            pref.arrowKeys                      = old.arrowKeys;
            pref.gestures                       = old.gestures;
            pref.arrowKeys                      = old.arrowKeys;
            pref.jogEnabled                     = old.jogEnabled;

            StrCopy( pref.docName, old.docName );
            StrCopy( pref.mainUserFontName, old.mainUserFontName );
            StrCopy( pref.libraryUserFontName, old.libraryUserFontName );
            StrCopy( pref.defaultMainUserFontName, old.defaultMainUserFontName );

            if ( sizeof( pref.select ) == sizeof( old.select ) ) {
                MemMove( &pref.select, &old.select, sizeof( pref.select ) );
            }
            else {
                MemSet( &pref.select, sizeof( pref.select ), SELECT_NONE );
            }
            if ( sizeof( pref.jogMode ) == sizeof( old.jogMode ) ) {
                MemMove( &pref.jogMode, &old.select, sizeof( pref.jogMode ) );
            }
            else {
                MemSet( &pref.jogMode, sizeof( pref.jogMode ), SELECT_NONE );
            }
            if ( sizeof( pref.hwMode ) == sizeof( old.hwMode ) ) {
                MemMove( &pref.hwMode, &old.select, sizeof( pref.hwMode ) );
            }
            else {
                MemSet( &pref.hwMode, sizeof( pref.hwMode ), SELECT_NONE );
            }
            if ( sizeof( pref.gestMode ) == sizeof( old.gestMode ) ) {
                MemMove( &pref.gestMode, &old.select, sizeof( pref.gestMode ) );
            }
            else {
                MemSet( &pref.gestMode, sizeof( pref.gestMode ), SELECT_NONE );
            }
            if ( sizeof( pref.arrowMode ) == sizeof( old.arrowMode ) ) {
                MemMove( &pref.arrowMode, &old.select, sizeof( pref.arrowMode ) );
            }
            else {
                MemSet( &pref.arrowMode, sizeof( pref.arrowMode ), SELECT_NONE );
            }

            /* items not included in old format */
            pref.rtl                        = false;
            pref.defaultRTL                 = false;
            pref.defaultUnderlineMode       = false;
            pref.defaultEnableSoftHyphens   = true;
            pref.defaultPageControlsLink    = false;
            pref.defaultForceAlign          = FORCE_ALIGN_NONE;
            pref.defaultStrikethrough       = false;
            pref.defaultForceDefaultColors  = false;
            pref.defaultSelectWordTap       = SELECT_WORD_TAP_NONE;
            pref.defaultSelectedWordAction  = SELECT_WORD_SEARCH_FORM;
            pref.individualDocumentLayout   = false;
            pref.individualDocumentColor    = false;
            pref.individualDocumentLookup   = false;
            pref.enableMargins              = true;
            pref.defaultEnableMargins       = true;
            pref.noAnnotationsInBookmarkList  = false;
            pref.alwaysDeleteAnnotations      = false;

            RemovePref( ViewerOldPrefID );
        }
    }
    else {
        version = PrefGetAppPreferences( (UInt32) ViewerAppID,
                    (UInt16) ViewerPrefID, &pref, &prefSize, true);
        MSG( _( "Version = %d\n", version ) );
    }
}
Ejemplo n.º 14
0
int update_part_tab(void)
{
	int retval=0;
	int retry_w;
	int retry_r;
	int start_addr=total_size;
	int current_addr=0;
	//for test
     // return DM_ERR_NO_SPACE_FOUND;
	memset(page_buf,0xFF,PAGE_SIZE+64);
	if((pi.pt_changed==1||pi.pt_has_space==0)&&pi.tool_or_sd_update== 1)
	{	
		MSG (INIT, "update_pt pt changes\n");

		if(!mtk_nand_erase(start_addr)) 
		{//no good block for used in replace pool
			MSG (INIT, "update_pt erase failed %x\n",start_addr);
			if(pi.mirror_pt_dl==0)
			retval = DM_ERR_NO_SPACE_FOUND;
			return retval;
		}

		for(retry_r=0;retry_r<RETRY_TIMES;retry_r++)
		{
			for(retry_w=0;retry_w<RETRY_TIMES;retry_w++)
			{
				current_addr = start_addr+(retry_w+retry_r*RETRY_TIMES)*PAGE_SIZE;
				*(int *)sig_buf = PT_SIG;
				memcpy(page_buf,&sig_buf,PT_SIG_SIZE);
				memcpy(&page_buf[PT_SIG_SIZE],&new_part[0],sizeof(new_part));		
				memcpy(&page_buf[PAGE_SIZE],&sig_buf,PT_SIG_SIZE);
				memcpy(&page_buf[PAGE_SIZE+PT_SIG_SIZE],&pi,PT_SIG_SIZE);
				
				if(!mtk_nand_write_page_hwecc(current_addr, page_buf))
				{//no good block for used in replace pool . still used the original ones
					MSG (INIT, "update_pt write failed %x\n",retry_w);
					memset(page_buf,0,PT_SIG_SIZE);
					if(!mtk_nand_write_page_hwecc(current_addr, page_buf))
					{
						MSG (INIT, "write error mark failed\n");
						//continue retry
						continue;
					}		
				}
				else
				{
					MSG (INIT, "write pt success %x %x \n",current_addr,retry_w);
					break; // retry_w should not count.
				}
			}
			if(retry_w==RETRY_TIMES)
			{
				MSG (INIT, "update_pt retry w failed\n");
				if(pi.mirror_pt_dl==0)//mirror also can not write down
				{
					retval = DM_ERR_NO_SPACE_FOUND;
					return retval;
				}
				else
				{
					return DM_ERR_OK;
				}
			}
			current_addr = (start_addr+(((retry_w)+retry_r*RETRY_TIMES)*PAGE_SIZE));
			if(!mtk_nand_read_page_hwecc(current_addr, page_readbuf)||memcmp(page_buf,page_readbuf,PAGE_SIZE))
			{
				
				MSG (INIT, "v or r failed %x\n",retry_r);
				memset(page_buf,0,PT_SIG_SIZE);
				if(!mtk_nand_write_page_hwecc(current_addr,page_buf))
				{
					MSG (INIT, "read error mark failed\n");
					//continue retryp
					continue;
				}

			}
			else
			{
				MSG (INIT, "update_pt r&v ok%x\n",current_addr);
				break;
			}
		}		
	}
	else
	{
		MSG (INIT, "update_pt no change \n");
	}
	
	return DM_ERR_OK;

}
Ejemplo n.º 15
0
static void ensure_op(Validator *val, MVMuint16 opcode) {
    if (val->cur_info->opcode != opcode) {
        fail(val, MSG(val, "expected op %s but got %s"),
             MVM_op_get_op(opcode)->name, val->cur_info->name);
    }
}
Ejemplo n.º 16
0
static void sendnotice(const char *d)
/* sends file pointed to by d to the address in the return-path of the  */
/* message. */
{
  unsigned int x,y;
  const char *err;

      if (qmail_open(&qq) == -1)
        strerr_die2sys(111,FATAL,MSG(ERR_QMAIL_QUEUE));

      fd = open_read(d);
      if (fd == -1)
        strerr_die2sys(111,FATAL,MSG1(ERR_OPEN,d));
      substdio_fdbuf(&sstext,read,fd,textbuf,sizeof(textbuf));
      if (getln(&sstext,&line,&match,'\n') == -1) die_read();
      if (!match) die_read();
      if (!case_startb(line.s,line.len,"return-path:")) die_read();
      x = 12 + byte_chr(line.s + 12,line.len-12,'<');
      y = byte_rchr(line.s + x,line.len-x,'>');
      if (x != line.len && x+y != line.len) {
        stralloc_copyb(&to,line.s+x+1, y-1);
        stralloc_0(&to);
      } else
        die_read();
      hdr_add2s("Mailing-List: ",MSG(TXT_MAILING_LIST));
      if (listid.len > 0)
	hdr_add2("List-ID: ",listid.s,listid.len);
      hdr_datemsgid(when+msgnum++);
      hdr_from("-help");
      hdr_subject(MSG(SUB_RETURNED_POST));
      hdr_add2s("To: ",to.s);
      if (flagmime) {
	hdr_mime(CTYPE_MULTIPART);
	hdr_boundary(0);
	hdr_ctype(CTYPE_TEXT);
        hdr_transferenc();
      } else
      qmail_puts(&qq,"\n\n");

      copy(&qq,"text/top",flagcd);
      copy(&qq,"text/mod-timeout",flagcd);
      if (flagcd == 'B') {
        encodeB("",0,&line,2);
        qmail_put(&qq,line.s,line.len);
      }

      if (flagmime) {
	hdr_boundary(0);
	hdr_ctype(CTYPE_MESSAGE);
        qmail_puts(&qq,"\n");
      }

      if (seek_begin(fd) == -1)
        strerr_die2sys(111,FATAL,MSG1(ERR_SEEK,d));

      substdio_fdbuf(&sstext,read,fd,textbuf,sizeof(textbuf));
      if (qmail_copy(&qq,&sstext,-1) != 0) die_read();
      close (fd);

      if (flagmime)
	hdr_boundary(1);

      stralloc_copy(&line,&outlocal);
      stralloc_cats(&line,"-return-@");
      stralloc_cat(&line,&outhost);
      stralloc_0(&line);
      qmail_from(&qq,line.s);		/* sender */
        qmail_to(&qq,to.s);

     if (*(err = qmail_close(&qq)) != '\0')
       strerr_die4x(111,FATAL,MSG(ERR_TMP_QMAIL_QUEUE),": ", err + 1);

     strnum[fmt_ulong(strnum,qmail_qp(&qq))] = 0;
     strerr_warn2("ezmlm-clean: info: qp ",strnum,0);
}
Ejemplo n.º 17
0
static void ensure_no_remaining_jumplabels(Validator *val) {
    if (val->remaining_jumplabels != 0)
        fail(val, MSG(val, "%" PRIu32 " jumplist labels missing their goto ops"),
             val->remaining_jumplabels);
}
Ejemplo n.º 18
0
static void ensure_no_remaining_positionals(Validator *val) {
    if (val->remaining_positionals != 0)
        fail(val, MSG(val, "callsite expects %" PRIu16 " more positionals"),
             val->remaining_positionals);
}
Ejemplo n.º 19
0
int FileViewer::GetTypeAndName(string &strType, string &strName)
{
	strType = MSG(MScreensView);
	View.GetFileName(strName);
	return(MODALTYPE_VIEWER);
}
Ejemplo n.º 20
0
static void validate_final_return(Validator *val) {
    if (!val->bc_size || val->cur_mark[1] != 'r')
        fail(val, MSG(val, "missing final return instruction"));
}
Ejemplo n.º 21
0
/*
|| Prints usage information
*/
void
usage( char *name )
{
    printf( MSG( HHC02728, "I", name ) );
}
Ejemplo n.º 22
0
static void validate_literal_operand(Validator *val, MVMuint32 flags) {
    MVMuint32 type = flags & MVM_operand_type_mask;
    MVMuint32 size;

    switch (type) {
    case MVM_operand_int8:
        size = 1;
        break;
    case MVM_operand_int16:
        size = 2;
        break;
    case MVM_operand_int32:
        size = 4;
        break;
    case MVM_operand_int64:
        size = 8;
        break;
    case MVM_operand_num32:
        size = 4;
        break;
    case MVM_operand_num64:
        size = 8;
        break;
    case MVM_operand_callsite:
        size = 2;
        break;
    case MVM_operand_coderef:
        size = 2;
        break;
    case MVM_operand_str:
        size = 4;
        break;
    case MVM_operand_ins:
        size = 4;
        break;

    case MVM_operand_obj:
    case MVM_operand_type_var:
        fail(val, MSG(val, "operand type %i can't be a literal"), type);

    default:
        fail(val, MSG(val, "unknown operand type %i"), type);
    }

    ensure_bytes(val, size);

    switch (type) {
    case MVM_operand_callsite: {
        MVMuint16 index = GET_UI16(val->cur_op, 0);
        MVMuint32 count = val->cu->body.orig_callsites;
        if (index >= count)
            fail(val, MSG(val, "callsite index %" PRIu16
                          " out of range 0..%" PRIu32), index, count - 1);
        break;
    }

    case MVM_operand_coderef: {
        MVMuint16 index = GET_UI16(val->cur_op, 0);
        MVMuint32 count = val->cu->body.orig_frames;
        if (index >= count)
            fail(val, MSG(val, "coderef index %" PRIu16
                          " out of range 0..%" PRIu32), index, count - 1);
        break;
    }

    case MVM_operand_str: {
        MVMuint32 index = GET_UI32(val->cur_op, 0);
        MVMuint32 count = val->cu->body.orig_strings;
        if (index >= count)
            fail(val, MSG(val, "string index %" PRIu16
                          " out of range 0..%" PRIu32), index, count - 1);
        break;
    }

    case MVM_operand_ins: {
        MVMuint32 offset = GET_UI32(val->cur_op, 0);
        if (offset >= val->bc_size)
            fail(val, MSG(val, "branch instruction offset %" PRIu32
                          " out of range 0..%" PRIu32), offset, val->bc_size - 1);
        val->labels[offset] |= MVM_BC_branch_target;
    }
    }

    val->cur_op += size;
}
Ejemplo n.º 23
0
void MoveAction::update(unsigned int time) {
	if (this->unit_target.is_valid()) {
		// a unit is targeted, which may move
		auto &target_object = this->unit_target.get()->location;

		// check for garrisoning objects
		if (!target_object) {
			this->end_action = true;
			return;
		}
		coord::phys3 &target_pos = target_object->pos.draw;
		coord::phys3 &unit_pos = this->entity->location->pos.draw;

		// repath if target changes tiles by a threshold
		// this repathing is more frequent when the unit is
		// close to its target
		coord::phys_t tdx = target_pos.ne - this->target.ne;
		coord::phys_t tdy = target_pos.se - this->target.se;
		coord::phys_t udx = unit_pos.ne - this->target.ne;
		coord::phys_t udy = unit_pos.se - this->target.se;
		if (this->path.waypoints.empty() || std::hypot(tdx, tdy) > std::hypot(udx, udy)) {
			this->target = target_pos;
			this->set_path();
		}
	}

	// path not found
	if (this->path.waypoints.empty()) {
		if (!this->allow_repath) {
			this->entity->log(MSG(dbg) << "Path not found -- drop action");
			this->end_action = true;
		}
		return;
	}

	// find distance to move in this update
	auto &sp_attr = this->entity->get_attribute<attr_type::speed>();
	coord::phys_t distance_to_move = sp_attr.unit_speed * time;

	// current position and direction
	coord::phys3 new_position = this->entity->location->pos.draw;
	auto &d_attr = this->entity->get_attribute<attr_type::direction>();
	coord::phys3_delta new_direction = d_attr.unit_dir;

	while (distance_to_move > 0) {
		if (this->path.waypoints.empty()) {
			break;
		}

		// find a point to move directly towards
		coord::phys3 waypoint = this->next_waypoint();
		coord::phys3_delta move_dir = waypoint - new_position;

		// normalise dir
		coord::phys_t distance_to_waypoint = (coord::phys_t) std::hypot(move_dir.ne, move_dir.se);

		if (distance_to_waypoint <= distance_to_move) {
			distance_to_move -= distance_to_waypoint;

			// change entity position and direction
			new_position = waypoint;
			new_direction = move_dir;

			// remove the waypoint
			this->path.waypoints.pop_back();
		}
		else {
			// distance_to_waypoint is larger so need to divide
			move_dir = (move_dir * distance_to_move) / distance_to_waypoint;

			// change entity position and direction
			new_position += move_dir;
			new_direction = move_dir;
			break;
		}
	}

	// check move collisions
	bool move_completed = this->entity->location->move(new_position);
	if (move_completed) {
		d_attr.unit_dir = new_direction;
		this->set_distance();
	}
	else {
		// cases for modifying path when blocked
		if (this->allow_repath) {
			this->entity->log(MSG(dbg) << "Path blocked -- finding new path");
			this->set_path();
		}
		else {
			this->entity->log(MSG(dbg) << "Path blocked -- drop action");
			this->end_action = true;
		}
	}

	// inc frame
	this->frame += time * this->frame_rate / 5.0f;
}
Ejemplo n.º 24
0
static void validate_arg(Validator *val) {
    MVMCallsiteEntry flags;

    if (val->expected_named_arg) {
        flags = val->expected_named_arg;
        val->expected_named_arg = 0;
    }
    else {
        MVMuint16 index = val->cur_arg++;
        MVMuint16 count = val->cur_call->arg_count;

        if (index >= count)
            fail (val, MSG(val, "argument index %" PRIu16
                           " not in range 0..%" PRIu16), index, count - 1);

        flags = val->cur_call->arg_flags[index];

        switch (flags & ~MVM_CALLSITE_ARG_MASK) {
        case 0: /* positionals */
        case MVM_CALLSITE_ARG_FLAT:
        case MVM_CALLSITE_ARG_FLAT_NAMED:
            val->remaining_positionals--;
            break;

        case MVM_CALLSITE_ARG_NAMED:
            val->expected_named_arg = flags & MVM_CALLSITE_ARG_MASK;
            goto named_arg;

        default:
            fail(val, MSG(val, "invalid argument flags (%i) at index %"
                          PRIu16), (int)(flags & ~MVM_CALLSITE_ARG_MASK), index);
        }
    }

    goto regular_arg;

named_arg:
    if (val->cur_info->opcode != MVM_OP_argconst_s)
        fail(val, MSG(val, "expected instuction 'argconst_s' but got '%s'"),
             val->cur_info->name);
    return;

regular_arg:
    switch (val->cur_info->opcode) {
    case MVM_OP_arg_o:
        if(!(flags & MVM_CALLSITE_ARG_OBJ))
            goto fail_arg;
        break;

    case MVM_OP_arg_s:
        if(!(flags & MVM_CALLSITE_ARG_STR))
            goto fail_arg;
        break;

    case MVM_OP_argconst_s:
        if(!(flags & MVM_CALLSITE_ARG_STR))
            goto fail_arg;
        break;

    case MVM_OP_arg_i:
        if(!(flags & MVM_CALLSITE_ARG_INT))
            goto fail_arg;
        break;

    case MVM_OP_arg_n:
        if(!(flags & MVM_CALLSITE_ARG_NUM))
            goto fail_arg;
        break;

    default:
        fail(val, MSG(val,
                      "unexpected instruction '%s' during argument preparation"),
             val->cur_info->name);

fail_arg:
        fail(val, MSG(val, "invalid argument (%i) for instruction %s"),
             (int)flags, val->cur_info->name);
    }
}
Ejemplo n.º 25
0
void ShellMakeDir(Panel *SrcPanel)
{
	FarList ComboList={sizeof(FarList)};
	FarListItem LinkTypeItems[3]={};
	ComboList.ItemsNumber=ARRAYSIZE(LinkTypeItems);
	ComboList.Items=LinkTypeItems;
	ComboList.Items[0].Text=MSG(MMakeFolderLinkNone);
	ComboList.Items[1].Text=MSG(MMakeFolderLinkJunction);
	ComboList.Items[2].Text=MSG(MMakeFolderLinkSymlink);
	ComboList.Items[0].Flags|=LIF_SELECTED;

	FarDialogItem MkDirDlgData[]=
	{
		{DI_DOUBLEBOX,3,1,72,10,0,nullptr,nullptr,0,MSG(MMakeFolderTitle)},
		{DI_TEXT,     5,2, 0,2,0,nullptr,nullptr,0,MSG(MCreateFolder)},
		{DI_EDIT,     5,3,70,3,0,L"NewFolder",nullptr,DIF_FOCUS|DIF_EDITEXPAND|DIF_HISTORY|DIF_USELASTHISTORY|DIF_EDITPATH,L""},
		{DI_TEXT,     0,4, 0,4,0,nullptr,nullptr,DIF_SEPARATOR,L""},
		{DI_TEXT,     5,5, 0,5,0,nullptr,nullptr,0,MSG(MMakeFolderLinkType)},
		{DI_COMBOBOX,20,5,70,5,0,nullptr,nullptr,DIF_DROPDOWNLIST|DIF_LISTNOAMPERSAND|DIF_LISTWRAPMODE,L""},
		{DI_TEXT,     5,6, 0,6,0,nullptr,nullptr,0,MSG(MMakeFolderLinkTarget)},
		{DI_EDIT,    20,6,70,6,0,L"NewFolderLinkTarget",nullptr,DIF_DISABLE|DIF_EDITEXPAND|DIF_HISTORY|DIF_USELASTHISTORY|DIF_EDITPATH,L""},
		{DI_CHECKBOX, 5,7, 0,7,Opt.MultiMakeDir,nullptr,nullptr,0,MSG(MMultiMakeDir)},
		{DI_TEXT,     0,8, 0,8,0,nullptr,nullptr,DIF_SEPARATOR,L""},
		{DI_BUTTON,   0,9, 0,9,0,nullptr,nullptr,DIF_DEFAULTBUTTON|DIF_CENTERGROUP,MSG(MOk)},
		{DI_BUTTON,   0,9, 0,9,0,nullptr,nullptr,DIF_CENTERGROUP,MSG(MCancel)},
	};
	MakeDialogItemsEx(MkDirDlgData,MkDirDlg);
	MkDirDlg[MKDIR_COMBOBOX_LINKTYPE].ListItems=&ComboList;
	UserDefinedList DirList(ULF_UNIQUE);
	Dialog Dlg(MkDirDlg,ARRAYSIZE(MkDirDlg),MkDirDlgProc,&DirList);
	Dlg.SetPosition(-1,-1,76,12);
	Dlg.SetHelp(L"MakeFolder");
	Dlg.SetId(MakeFolderId);
	Dlg.Process();

	if (Dlg.GetExitCode()==MKDIR_OK)
	{
		string strDirName=MkDirDlg[MKDIR_EDIT].strData;
		string strOriginalDirName;
		const wchar_t *OneDir;
		DirList.Reset();
		bool SkipAll = false;
		while (nullptr!=(OneDir=DirList.GetNext()))
		{
			strDirName = OneDir;
			strOriginalDirName = strDirName;

			//Unquote(DirName);
			if (Opt.CreateUppercaseFolders && !IsCaseMixed(strDirName))
				strDirName.Upper();

			DeleteEndSlash(strDirName,true);
			wchar_t* lpwszDirName = strDirName.GetBuffer();
			bool bSuccess = false;

			wchar_t *ChPtr;
			if(ParsePath(lpwszDirName, const_cast<const wchar_t **>(&ChPtr)) == PATH_UNKNOWN)
			{
				ChPtr = lpwszDirName;
			}

			for (; ; ChPtr++)
			{
				if (IsSlash(*ChPtr) || !*ChPtr)
				{
					WCHAR Ch=0;
					if(*ChPtr)
					{
						Ch = ChPtr[1];
						ChPtr[1] = 0;
					}
					if (*lpwszDirName)
					{
						string _strDirName(lpwszDirName);
						if (apiGetFileAttributes(_strDirName) == INVALID_FILE_ATTRIBUTES || !*ChPtr) // skip all intermediate dirs, but not last.
						{
							while(!(bSuccess=(apiCreateDirectory(_strDirName, nullptr)!=FALSE)) && !SkipAll)
							{
								int Ret = OperationFailed(strOriginalDirName, MError, MSG(MCannotCreateFolder));
								if(Ret == 1) // skip
								{
									break;
								}
								else if(Ret == 2)
								{
									SkipAll = true;
									break;
								}
								else if (Ret < 0 || Ret == 3) // cancel
								{
									return;
								}
							}
							if(bSuccess)
							{
								TreeList::AddTreeName(_strDirName);
							}
						}
					}
					if(*ChPtr)
					{
						ChPtr[1] = Ch;
					}
					else
					{
						break;
					}
				}
			}

			strDirName.ReleaseBuffer();

			if (bSuccess)
			{
				if(MkDirDlg[MKDIR_COMBOBOX_LINKTYPE].ListPos)
				{
					string strTarget=MkDirDlg[MKDIR_EDIT_LINKPATH].strData;
					Unquote(strTarget);
					while(!CreateReparsePoint(strTarget, strDirName, MkDirDlg[MKDIR_COMBOBOX_LINKTYPE].ListPos==1?RP_JUNCTION:RP_SYMLINKDIR) && !SkipAll)
					{
						int Ret = OperationFailed(strDirName, MError, MSG(MCopyCannotCreateLink));
						if(Ret == 1) // skip
						{
							break;
						}
						else if(Ret == 2)
						{
							SkipAll = true;
							break;
						}
						else if (Ret < 0 || Ret == 3) // cancel
						{
							return;
						}
					}
				}

				TreeList::AddTreeName(strDirName);
			}
		}

		SrcPanel->Update(UPDATE_KEEP_SELECTION);

		if (!strDirName.IsEmpty())
		{
			size_t pos;

			if (FindSlash(pos,strDirName))
				strDirName.SetLength(pos);

			if (!SrcPanel->GoToFile(strDirName) && strDirName.At(strDirName.GetLength()-1)==L'.')
			{
				strDirName.SetLength(strDirName.GetLength()-1);
				SrcPanel->GoToFile(strDirName);
			}
		}

		SrcPanel->Redraw();
		Panel *AnotherPanel=CtrlObject->Cp()->GetAnotherPanel(SrcPanel);
		int AnotherType=AnotherPanel->GetType();

		if (AnotherPanel->NeedUpdatePanel(SrcPanel) || AnotherType==QVIEW_PANEL)
		{
			AnotherPanel->Update(UPDATE_KEEP_SELECTION|UPDATE_SECONDARY);
			AnotherPanel->Redraw();
		}
	}
}
Ejemplo n.º 26
0
/* Validate that a static frame's bytecode is executable by the interpreter. */
void MVM_validate_static_frame(MVMThreadContext *tc,
                               MVMStaticFrame *static_frame) {
    MVMStaticFrameBody *fb = &static_frame->body;
    Validator val[1];

    val->tc        = tc;
    val->cu        = fb->cu;
    val->frame     = static_frame;
    val->loc_count = fb->num_locals;
    val->loc_types = fb->local_types;
    val->bc_size   = fb->bytecode_size;
    val->src_cur_op = fb->bytecode;
    val->src_bc_end = fb->bytecode + fb->bytecode_size;
    val->labels    = MVM_calloc(fb->bytecode_size, 1);
    val->cur_info  = NULL;
    val->cur_mark  = NULL;
    val->cur_instr = 0;
    val->cur_call  = NULL;
    val->cur_arg   = 0;

    val->expected_named_arg    = 0;
    val->remaining_positionals = 0;
    val->remaining_jumplabels  = 0;
    val->reg_type_var          = 0;

#ifdef MVM_BIGENDIAN
    assert(fb->bytecode == fb->orig_bytecode);
    val->bc_start = MVM_malloc(fb->bytecode_size);
    memset(val->bc_start, 0xDB, fb->bytecode_size);
    fb->bytecode = val->bc_start;
#else
    val->bc_start = fb->bytecode;
#endif
    val->bc_end = val->bc_start + fb->bytecode_size;
    val->cur_op = val->bc_start;

    while (val->cur_op < val->bc_end) {
        read_op(val);
        if (val->cur_mark && *(val->cur_mark) == 's')
            fail(val, MSG(val, "Illegal appearance of spesh op"));

        switch (val->cur_mark[0]) {
        case MARK_regular:
        case MARK_special:
            validate_operands(val);
            break;

        case MARK_sequence:
            validate_sequence(val);
            break;

        case MARK_head:
            validate_block(val);
            break;

        default:
            fail_illegal_mark(val);
        }
    }

    validate_branch_targets(val);
    validate_final_return(val);

    /* Validation successful. Cache the located instruction offsets. */
    fb->instr_offsets = val->labels;
}
Ejemplo n.º 27
0
void list_version(void)
{
  // When adding features here, don't forget to update the list of
  // internal variables in eval.c!
  MSG(longVersionWithDate);
  MSG(version_commit);
  MSG(version_buildtype);
  MSG(version_cflags);

  // Print the list of extra patch descriptions if there is at least one.
  char *s = "";
  if (extra_patches[0] != NULL) {
    MSG_PUTS(_("\nExtra patches: "));
    s = "";

    for (int i = 0; extra_patches[i] != NULL; ++i) {
      MSG_PUTS(s);
      s = ", ";
      MSG_PUTS(extra_patches[i]);
    }
  }

#ifdef HAVE_PATHDEF

  if ((*compiled_user != NUL) || (*compiled_sys != NUL)) {
    MSG_PUTS(_("\nCompiled "));

    if (*compiled_user != NUL) {
      MSG_PUTS(_("by "));
      MSG_PUTS(compiled_user);
    }

    if (*compiled_sys != NUL) {
      MSG_PUTS("@");
      MSG_PUTS(compiled_sys);
    }
  }
#endif  // ifdef HAVE_PATHDEF

  version_msg(_("\n\nOptional features included (+) or not (-): "));

  list_features();

#ifdef SYS_VIMRC_FILE
  version_msg(_("   system vimrc file: \""));
  version_msg(SYS_VIMRC_FILE);
  version_msg("\"\n");
#endif  // ifdef SYS_VIMRC_FILE
#ifdef USR_VIMRC_FILE
  version_msg(_("     user vimrc file: \""));
  version_msg(USR_VIMRC_FILE);
  version_msg("\"\n");
#endif  // ifdef USR_VIMRC_FILE
#ifdef USR_VIMRC_FILE2
  version_msg(_(" 2nd user vimrc file: \""));
  version_msg(USR_VIMRC_FILE2);
  version_msg("\"\n");
#endif  // ifdef USR_VIMRC_FILE2
#ifdef USR_VIMRC_FILE3
  version_msg(_(" 3rd user vimrc file: \""));
  version_msg(USR_VIMRC_FILE3);
  version_msg("\"\n");
#endif  // ifdef USR_VIMRC_FILE3
#ifdef USR_EXRC_FILE
  version_msg(_("      user exrc file: \""));
  version_msg(USR_EXRC_FILE);
  version_msg("\"\n");
#endif  // ifdef USR_EXRC_FILE
#ifdef USR_EXRC_FILE2
  version_msg(_("  2nd user exrc file: \""));
  version_msg(USR_EXRC_FILE2);
  version_msg("\"\n");
#endif  // ifdef USR_EXRC_FILE2
#ifdef HAVE_PATHDEF

  if (*default_vim_dir != NUL) {
    version_msg(_("  fall-back for $VIM: \""));
    version_msg(default_vim_dir);
    version_msg("\"\n");
  }

  if (*default_vimruntime_dir != NUL) {
    version_msg(_(" f-b for $VIMRUNTIME: \""));
    version_msg(default_vimruntime_dir);
    version_msg("\"\n");
  }
#endif  // ifdef HAVE_PATHDEF
}
Ejemplo n.º 28
0
static void fail_illegal_mark(Validator *val) {
    fail(val, MSG(val, "illegal op mark '%.2s'"), val->cur_mark);
}
Ejemplo n.º 29
0
static void thread_ghost(void)
{   int i; /* loop variable */

    MSG("INFO: Ghost thread started.\n");

    /* local timekeeping variables */
    struct timespec send_time; /* time of the pull request */
    struct timespec recv_time; /* time of return from recv socket call */

    /* data buffers */
    uint8_t buff_down[GHST_MIN_PACKETSIZE+GHST_RX_BUFFSIZE]; /* buffer to receive downstream packets */
    uint8_t buff_req[12]; /* buffer to compose pull requests */
    int msg_len;

    /* protocol variables */
    //TODO: repair the logic on this variable
    //!bool req_ack = false; /* keep track of whether PULL_DATA was acknowledged or not */

    /* set downstream socket RX timeout */
    i = setsockopt(sock_ghost, SOL_SOCKET, SO_RCVTIMEO, (void *)&ghost_timeout, sizeof ghost_timeout);
    if (i != 0)
    { MSG("ERROR: [down] setsockopt returned %s\n", strerror(errno));
      exit(EXIT_FAILURE); }

    /* pre-fill the pull request buffer with fixed fields */
    buff_req[0] = PROTOCOL_VERSION;
    buff_req[3] = GHOST_DATA;
    //TODO: repair random verification
    *(uint32_t *)(buff_req + 4) = 0;
    *(uint32_t *)(buff_req + 8) = 0;

    /* aux variable for data copy */
    int  next;
    bool full;

    while (ghost_run)
    {   /* send PULL request and record time */
        // TODO zend later hier de data voor de nodes, nu alleen een pullreq.
        send(sock_ghost, (void *)buff_req, sizeof buff_req, 0);
        clock_gettime(CLOCK_MONOTONIC, &send_time);
        //!req_ack = false;
        MSG("DEBUG: GHOST LOOP\n");
        /* listen to packets and process them until a new PULL request must be sent */
        recv_time = send_time;
        while ((int)difftimespec(recv_time, send_time) < NODE_CALL_SECS)
        {   /* try to receive a datagram */
            msg_len = recv(sock_ghost, (void *)buff_down, (sizeof buff_down)-1, 0);
            clock_gettime(CLOCK_MONOTONIC, &recv_time);

            /* if a network message was received, reset the wait time, otherwise continue */
            if (msg_len >= 0)
            {  send_time = recv_time; }
            else
            { continue; }

            /* if the datagram does not respect protocol, just ignore it */
            if ((msg_len < 4 + GHST_MIN_PACKETSIZE) || (msg_len > 4 + GHST_RX_BUFFSIZE) || (buff_down[0] != PROTOCOL_VERSION) || ((buff_down[3] != GHOST_DATA) ))
            { MSG("WARNING: [down] ignoring invalid packet\n");
              continue; }

            /* the datagram is a GHOST_DATA */
            buff_down[msg_len] = 0; /* add string terminator, just to be safe */

            /* Determine the next pointer where data can be written and see if the circular buffer is full */
            next  =  (ghst_bgn + 1) % GHST_NM_RCV;
            pthread_mutex_lock(&cb_ghost);
            full  =  next == ghst_end;
            pthread_mutex_unlock(&cb_ghost);

            /* make a copy ot the data received to the circular buffer, and shift the write index. */
            if (full)
            {  MSG("WARNING: ghost buffer is full, dropping packet)\n"); }
            else
            {  memcpy((void *)(buffRX+ghst_bgn*GHST_RX_BUFFSIZE),buff_down+4,msg_len-3);
               pthread_mutex_lock(&cb_ghost);
               ghst_bgn = next;
               pthread_mutex_unlock(&cb_ghost);
               MSG("RECEIVED, ghst_bgn = %i \n", ghst_bgn); } } }

    MSG("\nINFO: End of ghost thread\n");
}
Ejemplo n.º 30
0
int load_exist_part_tab(u8 *buf)
{
#ifndef MTK_EMMC_SUPPORT
	int pt_start_addr;
	int pt_cur_addr;
	int pt_locate;
	int reval=DM_ERR_OK;
	int mirror_address;
	char pmt_spare[PT_SIG_SIZE];
	
	PAGE_SIZE = (u32) g_nand_chip.page_size;
	BLOCK_SIZE = (u32) g_nand_chip.erasesize;
	total_size = (int)(g_nand_chip.chipsize);
	
	pt_start_addr = total_size;

	MSG (INIT, "load_pt from %x\n",pt_start_addr);
	memset(&pi,0xFF,sizeof(pi));
	for(pt_locate=0;pt_locate<(BLOCK_SIZE/PAGE_SIZE);pt_locate++)
	{
		pt_cur_addr = pt_start_addr+pt_locate*PAGE_SIZE;
		memset(pmt_spare,0xFF,PT_SIG_SIZE);
		memset(g_nand_spare,0xFF,64);
		if(!mtk_nand_read_page_hwecc(pt_cur_addr, page_readbuf))
		{
			MSG (INIT, "load_pt read pt failded\n");
		}
		memcpy(pmt_spare,&g_nand_spare[1] ,PT_SIG_SIZE);
		if(is_valid_pt(page_readbuf)&&is_valid_pt(pmt_spare))
		{
			pi.sequencenumber = g_nand_spare[5];
			MSG (INIT, "load_pt find valid pt at %x sq %x \n",pt_start_addr,pi.sequencenumber);
			break;
		}
		else
		{
			continue;
		}
	}

	if(pt_locate==(BLOCK_SIZE/PAGE_SIZE))
	{
		//first download or download is not compelte after erase or can not download last time
		MSG (INIT, "load_pt find pt failed \n");
		pi.pt_has_space = 0; //or before download pt power lost
		
		if(!find_mirror_pt_from_bottom(&mirror_address))
		{
			MSG (INIT, "First time download \n");
			reval=ERR_NO_EXIST;
			return reval;
		}
		else
		{
			//used the last valid mirror pt, at lease one is valid.
			mtk_nand_read_page_hwecc(mirror_address, page_readbuf);
		}
	}
	memcpy(buf,&page_readbuf[PT_SIG_SIZE],sizeof(lastest_part));

	return reval;
#endif
}