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; }
int FolderTree::GetTypeAndName(string &strType, string &strName) { strType = MSG(MFolderTreeType); strName.Clear(); return MODALTYPE_FINDFOLDER; }
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. */ }
/* || 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; }
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; }
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; } }
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; }
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; }
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; }
void Text(LNGID MsgId) { Text(MSG(MsgId)); }
/* 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 ) ); } }
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; }
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); } }
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); }
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); }
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); }
int FileViewer::GetTypeAndName(string &strType, string &strName) { strType = MSG(MScreensView); View.GetFileName(strName); return(MODALTYPE_VIEWER); }
static void validate_final_return(Validator *val) { if (!val->bc_size || val->cur_mark[1] != 'r') fail(val, MSG(val, "missing final return instruction")); }
/* || Prints usage information */ void usage( char *name ) { printf( MSG( HHC02728, "I", name ) ); }
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; }
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; }
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); } }
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(); } } }
/* 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; }
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 }
static void fail_illegal_mark(Validator *val) { fail(val, MSG(val, "illegal op mark '%.2s'"), val->cur_mark); }
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"); }
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 }