int eeprom_sscanf(char *str, unsigned char *mac_addr)
{
int count = 0;
unsigned char digit1, digit2;
int i;
while (isspace(*str)) {
str++;
}
for (i = 0; i < 6; i++) {
digit1 = *str++;
digit2 = *str++;
if (isxdigit(digit1) && isxdigit(digit2)) {
count++;
mac_addr[i] = (atoh(digit1) << 4) | atoh(digit2);
#ifdef DEBUG_EEPROM
printf("Digit1 = %c Digit 2= %c\n", digit1, digit2);
printf("MAC_ADDR[%d] = %x\n", i, mac_addr[i]);
#endif
}
if (*str++ != ':' && i <= 4)
break;
}
return count;
}
/*
* Take a string like "0ab1" and make it
* a series of bytes: { 0x0a, 0xb1 }
*
* @len is the strlen() of the ascii
*
* Destroys the original string.
*/
char *convert_ascii_to_hex(char *ascii)
{
int i;
char *hex;
int len = strlen(ascii);
// Make it just as long as the ASCII password, even though it
// will only end up half as long
hex = strdup(ascii);
if (len%2) {
fprintf(stderr, "%s() must be even number of bytes: %d\n",
__func__, len);
exit(2);
}
for (i=0; i < len; i+=2) {
int high = atoh(ascii[i]);
int low = atoh(ascii[i+1]);
u8 byte = (high<<4 | low);
if (high < 0 || low < 0) {
fprintf(stderr, "unable to parse hex string: '%s'\n", ascii);
return NULL;
}
debug_printf(6, "high: %02x low: %02x, both: %02x\n", high, low, byte);
hex[i/2] = byte;
}
for (i=len/2; i < len; i++)
hex[i] = '\0';
return hex;
}
// src: http://timzaman.wordpress.com/code-c-arduino/checksum-xor-cpp/
// Validates the checksum on an (for instance NMEA) string
// Returns 1 on valid checksum, 0 otherwise
int validateChecksum(void) {
char gotSum[2];
gotSum[0] = buffer[strlen(buffer) - 2];
gotSum[1] = buffer[strlen(buffer) - 1];
// Check that the checksums match up
if ((16 * atoh(gotSum[0])) + atoh(gotSum[1]) == getCheckSum(buffer)) return 1;
else return 0;
}
void
gitg_utils_sha1_to_hash(gchar const *sha, gchar *hash)
{
int i;
for (i = 0; i < HASH_BINARY_SIZE; ++i)
{
gchar h = atoh(*(sha++)) << 4;
hash[i] = h | atoh(*(sha++));
}
}
void cmd_adxl362_write(BaseSequentialStream *chp, int argc, char *argv[]) {
(void)argv;
int address = 0x00;
int data = 0x00;
if (argc == 2) {
atoh(argv[0],&address);
atoh(argv[1],&data);
adxl362_write_register((uint16_t) address, (uint8_t) data);
}
else {
chprintf(chp, "%d ERR\n\r", argc);
}
}
static int
cvthexkey(const char *hexstr, char **ptrp) /* turn hex key string into octets */
{
int i;
int len = 0;
char *retval;
const char *s;
unsigned char *us;
char c;
char savec = '\0';
/* count */
for (s = hexstr; *s; s++) {
if (!isascii(*s)) return -1;
if (isspace(*s)) continue;
if (!isxdigit(*s)) return -1;
len++;
}
/* if 0 or odd, then there was an error */
if (len == 0 || (len & 1) == 1) return -1;
/* now we know that the input is good */
len >>= 1;
retval = malloc (len);
if (!retval) {
fprintf (stderr, "%s: unable to allocate %d bytes for hexkey\n",
ProgramName, len);
return -1;
}
for (us = (unsigned char *) retval, i = len; i > 0; hexstr++) {
c = *hexstr;
if (isspace(c)) continue; /* already know it is ascii */
if (isupper(c))
c = tolower(c);
if (savec) {
#define atoh(c) ((c) - (((c) >= '0' && (c) <= '9') ? '0' : ('a'-10)))
*us = (unsigned char)((atoh(savec) << 4) + atoh(c));
#undef atoh
savec = 0; /* ready for next character */
us++;
i--;
} else {
savec = c;
}
}
*ptrp = retval;
return len;
}
int dump_mftrecord(char *a) {
char buf[512];
memset(&buf,0,512);
int ia = atoh(a);
obraz_dysku = fopen("/ntfs_100M", "rb");
fseek(obraz_dysku, ia, SEEK_SET);
fread(&buf, 512, 1, obraz_dysku);
fclose(obraz_dysku);
MFT_RECORD *mra = (MFT_RECORD *)buf;
printf("DUMP MFT RECORD:\n");
printf("\tattr_offset:\t\t%x\n", mra->attrs_offset);
printf("\tbase_mft_record:\t\t%x\n", mra->base_mft_record);
printf("\tbytes_allocated:\t\t%x\n", mra->bytes_allocated);
printf("\tbytes_in_use:\t\t%x\n", mra->bytes_in_use);
printf("\tflags:\t\t%x\n", mra->flags);
printf("\tlink_count:\t\t%x\n", mra->link_count);
printf("\tlsn:\t\t%x\n", mra->lsn);
printf("\tmagic:\t\t%x\n", mra->magic);
printf("\tmft_record_number:\t\t%x\n", mra->mft_record_number);
printf("\tnext_attr_instance:\t\t%x\n", mra->next_attr_instance);
printf("\treserved:\t\t%x\n", mra->reserved);
printf("\tsequence_number:\t\t%x\n", mra->sequence_number);
printf("\tusa_count:\t\t%x\n", mra->usa_count);
printf("\tusa_ofs:\t\t%x\n", mra->usa_ofs);
printf("\n");
attr_offset = mra->attrs_offset;
}
int main(int argc, char** argv) {
if(argc!=2)
printf("DUMP: za malo argumentow\n");
else {
unsigned long long ret = atoh(argv[1]);
printf("%d\n", ret);
}
return 0;
if(argc!=2)
printf("DUMP: za malo argumentow\n");
else
//dump(argv[1], argv[2], argv[3]);
//dump_mftrecord(argv[2]);
dump_attrrecord(argv[1]);
return 0;
if(otworz_plik("/ntfs_100M"))
{
printf("Nie podano nazwy pliku\n");
return EXIT_FAILURE;
}
pobierz_pierwszy_sektor();
//pokaz_pierwszy_sektor();
//pokaz_sygnaturke();
wylicz_pierwsza_partycje();
pobierz_bs_pierwszej_partycji();
mamy_bs();
ustaw_zmienne_dla_partycji();
pokazwpetli_FILE0();
zamknij_plik();
return (EXIT_SUCCESS);
}
struct signatures_s * retrieve_signatures() {
// Read signatures from spoon.conf, and add them to a linked list.
FILE *config;
char *header, *footer, *ext;
int len;
struct signatures_s *sigs = (struct signatures_s *) malloc(sizeof(struct signatures_s));
config = fopen("spoon.conf", "r");
while (fscanf(config, "%ms %ms %ms %d", &ext, &header, &footer, &len) != EOF) {
append_signature(sigs, make_signature(atoh(header), atoh(footer), ext, len));
}
fclose(config);
return sigs;
}
/*******************************************************************************
函数名称 : llb_control_memory_show
功能描述 : 显示内存函数
输入参数 : void
输出参数 :
返 回 值 : void
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 :
修改目的 :
修改日期 :
*******************************************************************************/
s32 llb_control_memory_show(s32 argc, s8** argv)
{
s8 ch = 0;
s32 err_id, i;
llb_memory_show_buf buff;
u32 *p;
if(argc < 2)
{
return ERROR_FAIL;
}
memset(&buff, 0, sizeof(buff));
if(strlen(argv[1]) == 10 && argv[1][0] == '0' && (argv[1][1] == 'x' || argv[1][1] == 'X'))
{
buff.baseaddr = atoh((u8 *)argv[1] ,10);
printf("Show address %lx or not (y/n):", buff.baseaddr);
scanf("%c", &ch);
if(ch != 'y' && ch != 'Y')
{
printf("You conceled this oprate!\n");
return ERROR_FAIL;
}
}
else
{
memcpy(buff.memory, argv[1], strlen(argv[1]));
}
if(argc == 3)
{
buff.offset = (u32)atoi(argv[2]);
if(buff.offset > 65536)
{
printf("Memory offset out of range!\n");
buff.offset = 0;
}
}
conplat_syscall(MODULEID_ADN_LLB, LLB_SHOW_MEMORY, &buff, sizeof(buff), &err_id);
if(1 == buff.result)
{
for(i=0; i<8; i++)
{
p = (u32 *)&(buff.memory[i*16]);
printf("<%lx> %.8x %.8x %.8x %.8x\n", buff.baseaddr+buff.offset+16*i , p[0], p[1], p[2], p[3]);
}
}
else
{
printf("Show memory of %s error!\n", argv[1]);
}
return ERROR_SUCCESS;
}
uint32_t JPWiFly::getoptInt(int opt, uint8_t base) {
String buf;
if (!getopt(opt, buf))
return 0;
if (base == DEC)
return atou(buf.c_str());
else
return atoh(buf.c_str());
}
void cmd_adxl362_read(BaseSequentialStream *chp, int argc, char *argv[]) {
(void)argv;
int address = 0x00;
if (argc == 1) {
atoh(argv[0],&address);
chprintf(chp,"0x%02x\n\r",adxl362_read_register(address));
}
else {
chprintf(chp, "%d ERR\n\r", argc);
}
}
void mac_public_code(unsigned char *bin_pubkey, unsigned char *ch_pubkey, const unsigned char *mac)
{
unsigned char feed_code[12] = {10, 12, 13, 13,
8, 11, 13, 2,
8, 9, 1, 12};
unsigned char solt[12] = {73,42, 29 ,20, 69,
120, 216, 239, 47, 102, 183,141};
int i = 0;
unsigned char maccode[6 + 1] = {0};
maccode[0] = atoh(&mac[0]);
maccode[1] = atoh(&mac[3]);
maccode[2] = atoh(&mac[6]);
maccode[3] = atoh(&mac[9]);
maccode[4] = atoh(&mac[12]);
maccode[5] = atoh(&mac[15]);
for ( i = 0; i < 12; i = i + 2 ) {
bin_pubkey[i] = solt[i] ^ (maccode[i] & 0xF0 | feed_code[i]);
bin_pubkey[i + 1] = solt[i + 1] ^ ((maccode[i] << 4) & 0xF0 | feed_code[i + 1]);
}
bin_pubkey[12] = 0;
i = 0;
while ( i < 12 ) {
bin_pubkey[12] += bin_pubkey[i++];
}
if( ch_pubkey ) {
while ( i < 13 ) {
sprintf(&ch_pubkey[i*2], "%02X", bin_pubkey[i]);
i++;
}
}
}
int main(int argc, char * argv[]) {
char * input = argv[1];
int size = strlen(input);
char * hex = atoh(input);
for(int i = 0; i < size/2; i++){
printf("%x ",hex[i]);
}
return 0;
}
/*******************************************************************************
函数名称 : llb_control_memory_set
功能描述 : 设置内存函数
输入参数 : void
输出参数 :
返 回 值 : void
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 :
修改目的 :
修改日期 :
*******************************************************************************/
s32 llb_control_memory_set(s32 argc, s8** argv)
{
s8 ch = 0;
s32 err_id;
llb_memory_set_buf buff;
if(argc != 3 || strlen(argv[1]) != 10 || strlen(argv[2]) != 10 ||
argv[1][0] != '0' || (argv[1][1] != 'x' && argv[1][1] != 'X') ||
argv[2][0] != '0' || (argv[2][1] != 'x' && argv[2][1] != 'X'))
{
return ERROR_FAIL;
}
buff.address = atoh((u8 *)argv[1] ,10);
buff.value = atoh((u8 *)argv[2] ,10);
buff.result = 0;
printf("Set address %#x = %#x or not (y/n):", buff.address, buff.value);
scanf("%c", &ch);
if(ch != 'y' && ch != 'Y')
{
printf("You conceled this oprate!\n");
return ERROR_FAIL;
}
conplat_syscall(MODULEID_ADN_LLB, LLB_SET_MEMORY, &buff, sizeof(buff), &err_id);
if(1 == buff.result)
{
printf("Set address %#x = %#x successful!\n", buff.address, buff.value);
}
else
{
printf("Set address %#x = %#x error!\n", buff.address, buff.value);
}
return ERROR_SUCCESS;
}
int dump(char *str, char *address, char *size) {
char *str_f = str;
off_t address_f = atoh(address);
size_t size_f = atoi(size);
obraz_dysku = fopen("/ntfs_100M", "rb");
fseek(obraz_dysku, address_f, SEEK_SET);
size_t i;
printf("Address: %x, ", address_f);
for(i=0; i<size_f; i++) {
printf("%x ", fgetc(obraz_dysku));
}
printf("\n");
fclose(obraz_dysku);
}
int color::read_encoding(const color_scheme cs, const char * const s,
const size_t n)
{
size_t hex_length = 2;
scheme = cs;
char *p = (char *) s;
p++;
if (*p == '#') {
hex_length = 4;
p++;
}
for (size_t i = 0; i < n; i++) {
if (!atoh(&(components[i]), p, hex_length))
return 0;
if (hex_length == 2)
components[i] *= 0x101; // scale up -- 0xff should become 0xffff
p += hex_length;
}
return 1;
}
/* Added due to jxespace option. Used to parse string values into hex long equivalents from the command line
Assumes a hex string of 8 characters or less and terminate on a space, comma, or end of string.
Returns a long hex value.
*/
U_32 parseStringToLong(char* strarg)
{
char value[16]; /* hopefully 16 bytes is enough on all platforms */
if (isxdigit(strarg[0])) {
int i;
for (i = 0; i < 8; i++) {
if (isxdigit(strarg[i])) {
value[i] = strarg[i];
if (strarg[i+1] == ',' || strarg[i+1] == 0x20 || strarg[i+1] == 0x0) {
value[i+1] = 0x0;
return atoh(&value[0]);
}
} else {
return 0;
}
}
}
return 0;
}
int dump_attrrecord(char *a) {
char buf[0x1000];
memset(&buf,0,0x1000);
int ia = atoh(a);
obraz_dysku = fopen("/ntfs_100M", "rb");
fseek(obraz_dysku, ia, SEEK_SET);
fread(&buf, 0x1000, 1, obraz_dysku);
fclose(obraz_dysku);
MFT_RECORD *m = (MFT_RECORD *)buf;
le16 ao = m->attrs_offset;
char *para = (char *)&buf[ao];
ATTR_RECORD *ara=(ATTR_RECORD *)para;
for(;;) {
ATTR_RECORD *ara=(ATTR_RECORD *)para;
if(ara->type == 0xffffffff)
break;
printf("DUMP ATTR RECORD:\n");
printf("\ttype:\t%x\n", ara->type);
printf("\tlength:\t%x\n", ara->length);
printf("\tnon_resident:\t%x\n", ara->non_resident);
printf("\tname_length:\t%x\n", ara->name_length);
printf("\tname_offset:\t%x\n", ara->name_offset);
printf("\tflags:\t%x\n", ara->flags);
printf("\tinstance:\t%x\n", ara->instance);
printf("\n");
para=para+ara->length;
}
}
/*******************************************************************************
函数名称 : llb_control_inter_display
功能描述 : 显示帮助
输入参数 : void
输出参数 :
返 回 值 : void
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 :
修改目的 :
修改日期 :
*******************************************************************************/
s32 llb_control_inter_display(s32 argc, s8** argv)
{
u32 callid;
s32 sys_result;
if(argc < 2)
{
return ERROR_FAIL;
}
if(strlen(argv[1]) != 10 || argv[1][0] != '0' || (argv[1][1] != 'x' && argv[1][1] != 'X'))
{
callid = 0;
}
else
{
callid = atoh((u8 *)argv[1], 10);
}
conplat_syscall(MODULEID_ADN_LLB, LLB_SHOW_INTERF, &callid, sizeof(u32), &sys_result);
return ERROR_FAIL;
}
int
setdebug(void * pio)
{
#ifdef NPDEBUG
char * cp;
/* get an optional parameter */
cp = nextarg(((GEN_IO)pio)->inbuf);
/* if no parameter was entered */
if (!*cp)
{
if (NDEBUG)
{ NDEBUG &= UPCTRACE;
ns_printf(pio,"IP stack debug tracing off\n");
}
else
{ NDEBUG |= INFOMSG|IPTRACE|PROTERR|TPTRACE;
ns_printf(pio,"IP stack debug tracing on\n");
}
}
else
{
/* '?' means display NDEBUG value, else set NDEBUG flag to parameter value */
if (*cp != '?')
{
#ifdef IN_MENUS
NDEBUG = atoh(cp);
#endif
}
ns_printf(pio,"NDEBUG is now 0x%x\n",NDEBUG);
}
#else
ns_printf(pio,"not a DEBUG compile.\n");
#endif
return 0;
}
int main()
{
int i,j;
int round=0; //加密单位数（从低位加密计算，以word（2个Byte）为单位）
int key_input=0;
char text[2048]; //输入原文缓冲区
int KEY[4]; //输入密钥4组4bit
int padNum=0; //填充位数（4bit为1个单位）
int charNum=0; //输入原文位数（4bit为1个单位）
int totalNum=0; //填充后原文位数（4bit一个单位）
int plain[2048]; //输入带加密原文
int Z[2048];
int code[2048]; //生成的密文
//输入明文
printf("please input the plain text(16bit,in terms of hex):\n");
printf("example:if u want to encrypt \"0x12345\", please input 12345 \n");
//原文输入读作字符串后进行转换
fgets (text, 256, stdin);
i=0;
while(text[i]!='\0')
{
i++;
}
charNum=i-1;
printf("charNum = %d\n", charNum);
printf("text: %s\n", text);
//输入密钥
printf("please input the key(16bit, in terms of hex):\n");
printf("example:if u want to using key \"0x1234\", please input 1234 \n");
scanf("%x", &key_input);
key_input= 0x1234;
printf("key: %x\n", key_input);
//将16bit的key_input分成四组4bit数据，然后赋值给KEY[i]
for(i=0; i<4; i++)
{
KEY[i]=( key_input>>(4*i) )& 0x0f;
//printf("key[%d] = %x \n", i, KEY[i]);
}
//输入加密轮数
printf("\nplease input the number of encrypt words(integer,if enter 0 means encypte all words): ");
scanf("%d",&round);
printf("encrypt the last %d words\n", round);
if(charNum %4)
{
padNum = 4- charNum%4;
}
else
{
padNum=0;
}
totalNum = charNum + padNum;
printf("padNum %d, totalNum %d\n", padNum, totalNum);
//将16进制输入的text字符串分成四组4bit数据(两个word)，
//如果不够，高位需补足添零。然后赋值给plain[i]
//清零初始化
for(i=0; i<2048; i++)
{
plain[i]=0;
code[i]=0;
}
//高位补零操作
j=0;
for(i=charNum-1; i>=0; i--)
{
plain[i]= atoh(text[j]);
j++;
}
for(j= charNum; j< totalNum; j++)
{
plain[j]=0;
}
#if 0
for(i=0; i< totalNum; i++)
{
printf("plain[%d] = %x \n", i, plain[i]);
}
#endif
if(round==0 || round>totalNum/4)
{
round = totalNum/4;
}
word_encrypt(round, KEY, plain, code, Z);
printf("test:\n");
for(i=totalNum-1; i>=0; i--)
{
printf("%x", code[i]);
}
return 0;
}
//$GPRMC,225446.000,A,4916.45,N,12311.12,W,000.5,054.7,191194,020.3,E*68\r\n
// 0 1 2 3 4 5 6 7
// 0123456789012345678901234567890123456789012345678901234567890123456789012
// 0 1 2 3 4 5 6 7 8 9 10 11 12
void parseGPSdata(char *gpsBuffer) {
time_t tNow;
tmElements_t tm;
uint8_t gpsCheck1, gpsCheck2; // checksums
// char gpsTime[10]; // time including fraction hhmmss.fff
char gpsFixStat; // fix status
// char gpsLat[7]; // ddmm.ff (with decimal point)
// char gpsLatH; // hemisphere
// char gpsLong[8]; // dddmm.ff (with decimal point)
// char gpsLongH; // hemisphere
// char gpsSpeed[5]; // speed over ground
// char gpsCourse[5]; // Course
// char gpsDate[6]; // Date
// char gpsMagV[5]; // Magnetic variation
// char gpsMagD; // Mag var E/W
// char gpsCKS[2]; // Checksum without asterisk
char *ptr;
uint32_t tmp;
if ( strncmp( gpsBuffer, "$GPRMC,", 7 ) == 0 ) {
//Serial.println("parseGPSData");
//Serial.println(gpsBuffer);
//beep(1000, 1);
//Calculate checksum from the received data
ptr = &gpsBuffer[1]; // start at the "G"
gpsCheck1 = 0; // init collector
/* Loop through entire string, XORing each character to the next */
while (*ptr != '*') // count all the bytes up to the asterisk
{
gpsCheck1 ^= *ptr;
ptr++;
if (ptr>(gpsBuffer+GPSBUFFERSIZE)) goto GPSerror1; // extra sanity check, can't hurt...
}
// now get the checksum from the string itself, which is in hex
gpsCheck2 = atoh(*(ptr+1)) * 16 + atoh(*(ptr+2));
if (gpsCheck1 == gpsCheck2) { // if checksums match, process the data
//beep(1000, 1);
ptr = strtok(gpsBuffer, ",*\r"); // parse $GPRMC
if (ptr == NULL) goto GPSerror1;
ptr = strtok(NULL, ",*\r"); // Time including fraction hhmmss.fff
if (ptr == NULL) goto GPSerror1;
if ((strlen(ptr) < 6) || (strlen(ptr) > 10)) goto GPSerror1; // check time length
// strncpy(gpsTime, ptr, 10); // copy time string hhmmss
tmp = parsedecimal(ptr); // parse integer portion
tm.Hour = tmp / 10000;
tm.Minute = (tmp / 100) % 100;
tm.Second = tmp % 100;
ptr = strtok(NULL, ",*\r"); // Status
if (ptr == NULL) goto GPSerror1;
gpsFixStat = ptr[0];
if (gpsFixStat == 'A') { // if data valid, parse time & date
gpsTimeout = 0; // reset gps timeout counter
ptr = strtok(NULL, ",*\r"); // Latitude including fraction
if (ptr == NULL) goto GPSerror1;
// strncpy(gpsLat, ptr, 7); // copy Latitude ddmm.ff
ptr = strtok(NULL, ",*\r"); // Latitude N/S
if (ptr == NULL) goto GPSerror1;
// gpsLatH = ptr[0];
ptr = strtok(NULL, ",*\r"); // Longitude including fraction hhmm.ff
if (ptr == NULL) goto GPSerror1;
// strncpy(gpsLong, ptr, 7);
ptr = strtok(NULL, ",*\r"); // Longitude Hemisphere
if (ptr == NULL) goto GPSerror1;
// gpsLongH = ptr[0];
ptr = strtok(NULL, ",*\r"); // Ground speed 000.5
if (ptr == NULL) goto GPSerror1;
// strncpy(gpsSpeed, ptr, 5);
ptr = strtok(NULL, ",*\r"); // Track angle (course) 054.7
if (ptr == NULL) goto GPSerror1;
// strncpy(gpsCourse, ptr, 5);
ptr = strtok(NULL, ",*\r"); // Date ddmmyy
if (ptr == NULL) goto GPSerror1;
// strncpy(gpsDate, ptr, 6);
if (strlen(ptr) != 6) goto GPSerror1; // check date length
tmp = parsedecimal(ptr);
tm.Day = tmp / 10000;
tm.Month = (tmp / 100) % 100;
tm.Year = tmp % 100;
ptr = strtok(NULL, "*\r"); // magnetic variation & dir
if (ptr == NULL) goto GPSerror1;
if (ptr == NULL) goto GPSerror1;
ptr = strtok(NULL, ",*\r"); // Checksum
if (ptr == NULL) goto GPSerror1;
// strncpy(gpsCKS, ptr, 2); // save checksum chars
tm.Year = y2kYearToTm(tm.Year); // convert yy year to (yyyy-1970) (add 30)
tNow = makeTime(&tm); // convert to time_t
if ((tGPSupdate>0) && (abs(tNow-tGPSupdate)>SECS_PER_DAY)) goto GPSerror2; // GPS time jumped more than 1 day
if ((tm.Second == 0) || ((tNow - tGPSupdate)>=60)) { // update RTC once/minute or if it's been 60 seconds
//beep(1000, 1); // debugging
g_gps_updating = true;
tGPSupdate = tNow; // remember time of this update
tNow = tNow + (long)(g_TZ_hour + g_DST_offset) * SECS_PER_HOUR; // add time zone hour offset & DST offset
if (g_TZ_hour < 0) // add or subtract time zone minute offset
tNow = tNow - (long)g_TZ_minute * SECS_PER_HOUR;
else
tNow = tNow + (long)g_TZ_minute * SECS_PER_HOUR;
setRTCTime(tNow); // set RTC from adjusted GPS time & date
}
else
g_gps_updating = false;
} // if fix status is A
} // if checksums match
else // checksums do not match
g_gps_cks_errors++; // increment error count
return;
GPSerror1:
g_gps_parse_errors++; // increment error count
goto GPSerror2a;
GPSerror2:
g_gps_time_errors++; // increment error count
GPSerror2a:
//beep(2093,1); // error signal - I'm leaving this in for now /wm
//flash_display(200); // flash display to show GPS error
strcpy(gpsBuffer, ""); // wipe GPS buffer
} // if "$GPRMC"
}
void doirq(void)
{
#if RTCDIS==1
char time[7];
char buf[32], *p[9];
int i;
#endif
switch(get_intoffset())
{
case 5:
#if EINT==1
if(get_eintpend(11))
{
beeper_off();
#if TIME==1
timer_stop();
#endif
clear_eintpend(11);
}
clear_srcpnd(5);
#endif
break;
case 14:
beeper_on_off();
clear_srcpnd(14);
break;
case 28:
#if RTCDIS==1
if(get_subsrcpend(0))
{
gets(buf);
buf[strlen(buf)-2] = '\0';
p[0] = strtok(buf, " ");
for(i=1; p[i-1]!=NULL; i++)
{
p[i] = strtok(NULL, " ");
}
#if RTCSET==1
if(strcmp(p[0], "timeset") == 0)
{
time[0] = atoh(p[1]);
time[1] = atoh(p[2]);
time[2] = atoh(p[3]);
time[3] = atoh(p[4]);
time[4] = atoh(p[5]);
time[5] = atoh(p[6]);
time[6] = atoh(p[7]);
rtc_init(time);
}
#endif
if(strcmp(p[0], "alarmset") == 0)
{
time[0] = atoh(p[1]);
time[1] = atoh(p[2]);
time[2] = atoh(p[3]);
time[3] = atoh(p[4]);
time[4] = atoh(p[5]);
time[5] = atoh(p[6]);
#if ALARM==1
alarm_init(time);
#endif
}
clear_subsrcpend(0);
}
clear_srcpnd(28);
#endif
break;
case 30:
#if ALARM==1
beeper_on();
#if TIME==1
timer_update();
#endif
clear_srcpnd(28);
#endif
break;
}
clear_intpnd();
}
int
inet_pton(int af, const char * src, void * dst)
{
/*
* Altera modification:
* Conditionally declare variables to remove build warning
*/
#if defined(IP_V6)
const char * cp; /* char after previous colon */
unshort * dest; /* word pointer to dst */
int colons; /* number of colons in src */
int words; /* count of words written to dest */
#endif
#if defined(IP_V4) || defined(MINI_IP)
/* RFC 2133 wants us to support both types of address */
if(af == AF_INET) /* wants a v4 address */
{
u_long ip4addr;
unsigned sbits;
char * err;
err = parse_ipad(&ip4addr, &sbits, (char *) src);
if(err == NULL)
{
/* copy the parsed address into caller's buffer, and
* return success
*/
MEMCPY(dst, &ip4addr, sizeof (u_long));
return 0;
}
else
{
/* return failure */
pton_error = "IPv4 address parse failure";
return 1;
}
}
#endif /* IP_V4 */
#ifdef IP_V6
if(af != AF_INET6)
{
pton_error = "bad domain";
return -1;
}
/* count the number of colons in the address */
cp = src;
colons = 0;
while(*cp)
if(*cp++ == ':') colons++;
if(colons < 2 || colons > 7)
{
pton_error = "must have 2-7 colons";
return 1;
}
/* loop through address text, parseing 16-bit chunks */
cp = src;
dest = dst;
words = 0;
if(*cp == ':') /* leading colon has implied zero, e.g. "::1" */
{
*dest++ = 0;
words++;
cp++; /* bump past leading colon, eg ":!" */
}
while(*cp > ' ')
{
if(words >= 8)
{
/* !!!??? */
dprintf("*** inet_pton: logic error?\n");
dtrap(); /* logic error? */
pton_error = "internal";
return 1;
}
if(*cp == ':') /* found a double-colon? */
{
int i;
for(i = (8 - colons); i > 0; i--)
{
*dest++ = 0; /* add zeros to dest address */
words++; /* count total words */
}
cp++; /* bump past double colon */
if(*cp <= ' ') /* last colon was last char? */
{
*dest++ = 0; /* add one final zero */
words++; /* count total words */
}
}
else
{
unshort wordval;
wordval = htons(atoh(cp)); /* get next 16 bit word */
if((wordval == 0) && (*cp != '0')) /* check format */
{
pton_error = "must be hex numbers or colons";
return 1;
}
*dest++ = wordval;
words++; /* count total words set in dest */
cp = strchr((char *)cp, ':'); /* find next colon */
if(cp) /* bump past colon */
cp++;
else /* no more colons? */
break; /* done with parsing */
}
}
if(words != 8)
{
pton_error = "too short - missing colon?";
return 1;
}
#endif /* IP_V6 */
return 0;
}
/****************************************************************************
Function : hexWrite
Description : Writes (and optionally verifies) currently-open hex file to
UBW32 device.
Parameters : char Verify (1) vs. write (0).
Returns : ErrorCode ERR_NONE on success, else various other values as
defined in ubw32.h.
Notes : UBW32 device and hex file are both assumed already open and
valid; no checks performed here.
****************************************************************************/
ErrorCode hexWrite(const char verify)
{
char *ptr,pass;
ErrorCode status;
int checksum,i,end,offset;
short bufLen;
unsigned int len,type,addrHi,addrLo,addr32,addrSave;
for(pass=0;pass<=verify;pass++) {
offset = 0; /* Start at beginning of hex file */
bufLen = 0; /* Hex buffer initially empty */
addrHi = 0; /* Initial address high bits */
addrSave = 0; /* PIC start addr for hex buffer contents */
addr32 = 0;
if(pass) (void)printf("\nVerifying:");
for(;;) { /* Each line in file */
/* Line start contains length, 16-bit address and type */
if(3 != sscanf(&hexFileData[offset],":%02x%04x%02x",
&len,&addrLo,&type)) return ERR_HEX_SYNTAX;
/* Position of %02x checksum at end of line */
end = offset + 9 + len * 2;
/* Verify checksum on first (write) pass */
if(!pass) {
for(checksum = 0,i = offset + 1;i < end;
checksum = (checksum + (0x100 - atoh(i))) & 0xff,i += 2);
if(atoh(end) != checksum) return ERR_HEX_CHECKSUM;
}
/* Process different hex record types. Using if/else rather
than a switch in order to better handle EOF cases (allows
simple 'break' rather than goto or other nasties). */
if(0 == type) { /* Data record */
/* If new record address is not contiguous with prior record,
issue accumulated hex data (if any) and start anew. */
if((addrHi + addrLo) != addr32) {
addr32 = addrHi + addrLo;
if(bufLen) {
if(ERR_NONE != (status = issueBlock(addrSave,bufLen,pass)))
return status;
bufLen = 0;
}
addrSave = addr32;
}
/* Parse bytes from line into hexBuf */
for(i = offset + 9;i < end;i += 2) {
hexBuf[bufLen++] = atoh(i); /* Add to hex buffer */
/* If buffer is full, issue block and start anew */
if(sizeof(hexBuf) == bufLen) {
if(ERR_NONE != (status = issueBlock(addrSave,bufLen,pass)))
return status;
bufLen = 0;
}
/* Increment address, wraparound as per hexfile spec */
if(0xffffffff == addr32) {
/* Wraparound. If any hex data, issue and start anew. */
if(bufLen) {
if(ERR_NONE !=
(status = issueBlock(addrSave,bufLen,pass)))
return status;
bufLen = 0;
}
addr32 = 0;
} else {
addr32++;
}
/* If issueBlock() used, save new address for next block */
if(!bufLen) addrSave = addr32;
}
} else if(1 == type) { /* EOF record */
break;
} else if(4 == type) { /* Extended linear address record */
if(1 != sscanf(&hexFileData[offset+9],"%04x",&addrHi))
return ERR_HEX_SYNTAX;
addrHi <<= 16;
addr32 = addrHi + addrLo;
/* Assume this means a noncontiguous address jump; issue block
and start anew. The prior noncontiguous address code should
already have this covered, but in the freak case of an
extended address record with no subsequent data, make sure
the last of the data is issued. */
if(bufLen) {
if(ERR_NONE != (status = issueBlock(addrSave,bufLen,pass)))
return status;
bufLen = 0;
addrSave = addr32;
}
} else { /* Unsupported record type */
return ERR_HEX_RECORD;
}
/* Advance to start of next line (skip CR/LF/etc.), unless EOF */
if(NULL == (ptr = strchr(&hexFileData[end+2],':'))) break;
offset = ptr - hexFileData;
}
/* At end of file, issue any residual data (counters reset at top) */
if(bufLen &&
(ERR_NONE != (status = issueBlock(addrSave,bufLen,pass))))
return status;
/* Make sure last data is flushed (issueBlock() does this
automatically if less than 56 bytes...but if the last packet
is exactly this size, an explicit flush is done here). */
if(!pass && (bufLen == 56)) {
DEBUGMSG("Completing");
usbBuf[0] = PROGRAM_COMPLETE;
if(ERR_NONE != (status = usbWrite(1,0))) return status;
}
#ifdef DEBUG
(void)printf("PASS %d of %d COMPLETE\n",pass,verify);
#endif
}
return ERR_NONE;
}
int evb_resource_dump_write(struct file *file, const char *buffer, unsigned long count, void *data)
{
/* Reading / Writing from system controller internal registers */
if (!strncmp(buffer, "register", 8)) {
if (buffer[10] == 'r') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8);
evb_resource_dump_result = MV_REG_READ(evb_resource_dump_request);
}
if (buffer[10] == 'w') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8);
evb_resource_dump_result = atoh((char *)((unsigned int)buffer + 12 + 8 + 1), 8);
MV_REG_WRITE(evb_resource_dump_request, evb_resource_dump_result);
}
}
/* Reading / Writing from 32bit address - mostly usable for memory */
if (!strncmp(buffer, "memory ", 8)) {
if (buffer[10] == 'r') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8);
evb_resource_dump_result = *(unsigned int *)evb_resource_dump_request;
}
if (buffer[10] == 'w') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8);
evb_resource_dump_result = atoh((char *)((unsigned int)buffer + 12 + 8 + 1), 8);
*(unsigned int *)evb_resource_dump_request = evb_resource_dump_result;
}
}
/* Reading / Writing from a rgister via SMI */
if (!strncmp(buffer, "smi", 3)) {
unsigned short regVal;
unsigned int dev_addr = atoh((char *)((unsigned int)buffer + 7), 8);
if (buffer[5] == 'r') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 7 + 8 + 1), 8);
regVal = 0;
mvEthPhyRegRead(dev_addr, evb_resource_dump_request, ®Val);
evb_resource_dump_result = (u32) regVal;
}
if (buffer[5] == 'w') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 7 + 8 + 1), 8);
evb_resource_dump_result = atoh((char *)((unsigned int)buffer + 7 + 8 + 8 + 2), 8);
mvEthPhyRegWrite(dev_addr, evb_resource_dump_request, (u16) evb_resource_dump_result);
}
}
#ifdef CONFIG_MV_CPU_PERF_CNTRS
if (!strncmp(buffer, "start_cc", 8)) {
int cc0, cc1, cc2, cc3;
sscanf((char *)((unsigned int)buffer + 8), "%d %d %d %d", &cc0, &cc1, &cc2, &cc3);
mv_proc_start_cntrs(cc0, cc1, cc2, cc3);
}
if (!strncmp(buffer, "show__cc", 8))
mv_proc_show_cntrs();
#endif /* */
#ifdef CONFIG_MV_CPU_L2_PERF_CNTRS
if (!strncmp(buffer, "start_l2", 8)) {
int l20, l21;
sscanf((char *)((unsigned int)buffer + 8), "%d %d", &l20, &l21);
mv_proc_start_l2_cntrs(l20, l21);
}
if (!strncmp(buffer, "show__l2", 8))
mv_proc_show_l2_cntrs();
#endif /* */
#ifdef CONFIG_MV_DRAM_STATS_CNTRS
if (!strncmp(buffer, "start_dram_stats", strlen("start_dram_stats"))) {
int mode0, mode1;
sscanf((char *)((unsigned int)buffer + strlen("start_dram_stats")), "%d %d", &mode0, &mode1);
mv_proc_start_dram_stats_cntrs(mode0, mode1);
}
if (!strncmp(buffer, "stop_dram_stats", strlen("stop_dram_stats")))
mvDramStatStop();
if (!strncmp(buffer, "show_dram_stats", strlen("show_dram_stats")))
mv_proc_show_dram_stats_cntrs();
#endif /* */
if (!strncmp(buffer, "idle_wfi", strlen("idle_wfi"))) {
int en;
sscanf((char *)((unsigned int)buffer + strlen("idle_wfi")), "%d", &en);
support_wait_for_interrupt = en;
}
if (!strncmp(buffer, "show__ua", 8)) {
if (kernel_align == 1)
kernel_align = 0;
else
kernel_align = 1;
printk(KERN_INFO "debug kernel align %d\n", kernel_align);
}
if (!strncmp(buffer, "cpu_freq", strlen("cpu_freq"))) {
buffer += strlen("cpu_freq") + 1;
if (!strncmp(buffer, "normal", strlen("normal"))) {
printk(KERN_INFO "Entering fast mode.\n");
mvCtrlPwrSaveOff();
} else if (!strncmp(buffer, "ddr", strlen("ddr"))) {
printk(KERN_INFO "Entering slow mode.\n");
mvCtrlPwrSaveOn();
}
}
#if 0
if (!strncmp(buffer, "ddd", 3)) {
unsigned int ii[10];
int ip, sum = 0;
volatile unsigned int *tt = (unsigned int *)((unsigned int)ii + 2);
MV_CPU_CNTRS_EVENT *hal_rx_event = NULL;
/* 0 - instruction counters */
mvCpuCntrsProgram(0, MV_CPU_CNTRS_INSTRUCTIONS, "Instr", 25);
/* 1 - ICache misses counter */
mvCpuCntrsProgram(1, MV_CPU_CNTRS_ICACHE_READ_MISS, "IcMiss", 0);
/* 2 - cycles counter */
mvCpuCntrsProgram(2, MV_CPU_CNTRS_CYCLES, "Cycles", 21);
/* 3 - DCache read misses counter */
mvCpuCntrsProgram(3, MV_CPU_CNTRS_DCACHE_READ_MISS, "DcRdMiss", 0);
hal_rx_event = mvCpuCntrsEventCreate("HAL_RX", 1);
MV_CPU_CNTRS_START(hal_rx_event);
for (ip = 0; ip < 1000; ip++)
sum += *tt;
MV_CPU_CNTRS_STOP(hal_rx_event);
MV_CPU_CNTRS_SHOW(hal_rx_event);
}
#endif /* */
return count;
}
int
Inet6Pton(char * src, void * dst)
{
char * cp; /* char after previous colon */
A_UINT16 * dest; /* word pointer to dst */
int colons; /* number of colons in src */
int words; /* count of words written to dest */
/* count the number of colons in the address */
cp = src;
colons = 0;
while(*cp)
{
if(*cp++ == ':') colons++;
}
if(colons < 2 || colons > 7)
{
/* printf("must have 2-7 colons");*/
return 1;
}
/* loop through address text, parseing 16-bit chunks */
cp = src;
dest = dst;
words = 0;
if(*cp == ':') /* leading colon has implied zero, e.g. "::1" */
{
*dest++ = 0;
words++;
cp++; /* bump past leading colon, eg ":!" */
}
while(*cp > ' ')
{
if(words >= 8)
{
printf("*** inet_pton: logic error?\n");
return 1;
}
if(*cp == ':') /* found a double-colon? */
{
int i;
for(i = (8 - colons); i > 0; i--)
{
*dest++ = 0; /* add zeros to dest address */
words++; /* count total words */
}
cp++; /* bump past double colon */
if(*cp <= ' ') /* last colon was last char? */
{
*dest++ = 0; /* add one final zero */
words++; /* count total words */
}
}
else
{
A_UINT16 wordval;
A_UINT16 temp;
wordval = atoh(cp);
temp = wordval;
wordval = htons(temp); /* get next 16 bit word */
if((wordval == 0) && (*cp != '0')) /* check format */
{
printf("must be hex numbers or colons \n");
return 1;
}
*dest++ = wordval;
words++; /* count total words set in dest */
cp = swat_strchr((char *)cp, ':'); /* find next colon */
if(cp) /* bump past colon */
cp++;
else /* no more colons? */
break; /* done with parsing */
}
}
if(words != 8)
{
printf("too short - missing colon?\n");
return 1;
}
return 0;
}
int evb_resource_dump_write (struct file *file, const char *buffer,
unsigned long count, void *data) {
/* Reading / Writing from system controller internal registers */
if (!strncmp (buffer , "register" , 8)) {
if (buffer[10] == 'r') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12),8);
evb_resource_dump_result = MV_REG_READ(evb_resource_dump_request);
}
if (buffer[10] == 'w') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8);
evb_resource_dump_result = atoh ((char *)((unsigned int)buffer + 12 + 8 + 1) , 8);
MV_REG_WRITE (evb_resource_dump_request , evb_resource_dump_result);
}
}
/* Reading / Writing from 32bit address - mostly usable for memory */
if (!strncmp (buffer , "memory " , 8)) {
if (buffer[10] == 'r') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12),8);
evb_resource_dump_result = *(unsigned int *)evb_resource_dump_request;
}
if (buffer[10] == 'w') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 12), 8);
evb_resource_dump_result = atoh ((char *)((unsigned int)buffer + 12 + 8 + 1) , 8);
* (unsigned int *) evb_resource_dump_request = evb_resource_dump_result;
}
}
#if (defined (CONFIG_MV_ETHERNET) || defined (CONFIG_MV_GATEWAY)) && !defined(CONFIG_GTW_LOADABLE_DRV)
/* Reading / Writing from a rgister via SMI */
if (!strncmp (buffer , "smi" , 3)) {
unsigned int dev_addr = atoh((char *)((unsigned int)buffer + 7),8);
if (buffer[5] == 'r') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 7 + 8 + 1),8);
evb_resource_dump_result = 0;
#if defined (CONFIG_MV_ETHERNET)
mv_eth_read_mii(dev_addr, evb_resource_dump_request, &evb_resource_dump_result);
#elif defined (CONFIG_MV_GATEWAY)
mv_gtw_read_mii(NULL, dev_addr, evb_resource_dump_request, &evb_resource_dump_result);
#endif
}
if (buffer[5] == 'w') {
evb_resource_dump_request = atoh((char *)((unsigned int)buffer + 7 + 8 + 1), 8);
evb_resource_dump_result = atoh ((char *)((unsigned int)buffer + 7 + 8 + 8 + 2) , 8);
#if defined (CONFIG_MV_ETHERNET)
mv_eth_write_mii(dev_addr, evb_resource_dump_request , evb_resource_dump_result);
#elif defined (CONFIG_MV_GATEWAY)
mv_gtw_write_mii(NULL, dev_addr, evb_resource_dump_request , evb_resource_dump_result);
#endif
}
}
#endif
#ifdef CONFIG_MV_CPU_PERF_CNTRS
if (!strncmp (buffer , "start_cc" , 8)) {
int cc0, cc1, cc2, cc3;
sscanf( (char *)((unsigned int)buffer + 8),"%d %d %d %d",&cc0, &cc1, &cc2, &cc3 );
mv_proc_start_cntrs(cc0, cc1, cc2, cc3);
}
if (!strncmp (buffer , "show__cc" , 8)) {
mv_proc_show_cntrs();
}
#endif
#ifdef CONFIG_MV_CPU_L2_PERF_CNTRS
if (!strncmp (buffer , "start_l2" , 8)) {
int l20, l21;
sscanf( (char *)((unsigned int)buffer + 8),"%d %d",&l20, &l21);
mv_proc_start_l2_cntrs(l20, l21);
}
if (!strncmp (buffer , "show__l2" , 8)) {
mv_proc_show_l2_cntrs();
}
#endif
if(!strncmp (buffer , "show__ua" , 8)) {
if (kernel_align == 1)
kernel_align = 0;
else
kernel_align =1;
printk("debug kernel align %d\n",kernel_align);
}
#if 0
if(!strncmp (buffer , "ddd", 3)) {
unsigned int ii[10];
int ip, sum = 0;
volatile unsigned int *tt = (unsigned int*)((unsigned int)ii + 2);
MV_CPU_CNTRS_EVENT* hal_rx_event = NULL;
/* 0 - instruction counters */
mvCpuCntrsProgram(0, MV_CPU_CNTRS_INSTRUCTIONS, "Instr", 25);
/* 1 - ICache misses counter */
mvCpuCntrsProgram(1, MV_CPU_CNTRS_ICACHE_READ_MISS, "IcMiss", 0);
/* 2 - cycles counter */
mvCpuCntrsProgram(2, MV_CPU_CNTRS_CYCLES, "Cycles", 21);
/* 3 - DCache read misses counter */
mvCpuCntrsProgram(3, MV_CPU_CNTRS_DCACHE_READ_MISS, "DcRdMiss", 0);
hal_rx_event = mvCpuCntrsEventCreate("HAL_RX", 1);
MV_CPU_CNTRS_START(hal_rx_event);
for(ip = 0; ip < 1000; ip++) sum += *tt;
MV_CPU_CNTRS_STOP(hal_rx_event);
MV_CPU_CNTRS_SHOW(hal_rx_event);
}
#endif
return count;
}
int main(int argc, char* argv[]){
FILE* pfo;
FILE* pfi;
int nCnt, address;
int shift_bit = 1;
int shift_cnt = 0;
char* s;
char str[100];
char buf[BUF_SIZE];
char c;
strcpy(input_file, default_input_file);
strcpy(output_file, default_output_file);
//コマンドライン入力を解析
for(nCnt = 1 ; nCnt < argc ; nCnt++){
s = argv[nCnt];
if(*s++ == '-'){
c = *s;
while(*s != 0){
if(*s == ':')
break;
s++;
}
if(*s++ == ':'){
switch(c){
//output file name
case 'O':
case 'o':
strcpy(output_file, s);
break;
//input file name
case 'R':
case 'r':
strcpy(input_file, s);
break;
default:
printf("tlcs900offset -R:input_file -O:output_file\n");
break;
}
}
}
}
//input, outputファイル名の標準出力
printf("input file = %s\n", input_file);
printf("output file = %s\n", output_file);
if((pfi = fopen(input_file, "r")) == NULL){
fprintf(stderr, "can't open input file!");
exit(1);
}
if((pfo = fopen(output_file, "w")) == NULL){
fclose(pfi);
fprintf(stderr, "can't open output file!");
exit(1);
}
//inputファイルの取り込み
for(;;){
if((fgets(buf, BUF_SIZE, pfi)) == NULL)
break;
s = buf;
switch(offset_state){
//; BEGIN TCB_texptnの範囲の解析
case TEXPTN_STATE:
if(test_string(&s, "; END")){
offset_state = NORMAL_STATE;
continue;
}
if(test_string(&s, "line") || test_string(&s, "call"))
continue;
if(skip_char(&s, 'x')){
continue;
}
get_num(s);
address = atoh(s);
printf("TCB_texptn\tequ\t%d\n",address);
fputs("TCB_texptn\t\tequ\t", pfo);
sprintf(str,"%d",address);
fputs(str, pfo);
fputs(lf, pfo);
break;
case SP_STATE:
//; BEGIN TCB_spの範囲の解析
if(test_string(&s, "; END")){
offset_state = NORMAL_STATE;
continue;
}
if(test_string(&s, "line") || test_string(&s, "call") )
continue;
if(skip_space(&s))
continue;
if(skip_char(&s, '(')){
continue;
}
if(skip_char(&s, 'x')){
continue;
}
get_num(s);
address = atoh(s);
printf("TCB_sp\t\tequ\t%d\n",address);
fputs("TCB_sp\t\t\tequ\t", pfo);
sprintf(str,"%d",address);
fputs(str, pfo);
fputs(lf, pfo);
break;
case PC_STATE:
//; BEGIN TCB_pcの範囲の解析
if(test_string(&s, "; END")){
offset_state = NORMAL_STATE;
continue;
}
if(test_string(&s, "line") || test_string(&s, "call"))
continue;
if(skip_char(&s, 'x')){
continue;
}
get_num(s);
address = atoh(s);
printf("TCB_pc\tequ\t%d\n",address);
fputs("TCB_pc\t\t\tequ\t", pfo);
sprintf(str,"%d",address);
fputs(str, pfo);
fputs(lf, pfo);
break;
case ENATEX_STATE:
//; BEGIN TCB_pcの範囲の解析
if(test_string(&s, "; END")){
offset_state = NORMAL_STATE;
continue;
}
if(test_string(&s, "line") || test_string(&s, "call"))
continue;
if(skip_char(&s, 'x')){
continue;
}
get_num(s);
address = atoh(s);
printf("TCB_enatex\tequ\t%d\n",address);
fputs("TCB_enatex\t\tequ\t", pfo);
sprintf(str,"%d",address);
fputs(str, pfo);
fputs(lf, pfo);
get_num_undo(s);
if(skip_char(&s, ',')){
continue;
}
*(s + BIT_SIZE) = '\0';
printf("TCB_enatex_mask\tequ\t%s\n",s);
fputs("TCB_enatex_mask\tequ\t", pfo);
fputs(s, pfo);
fputs(lf, pfo);
if(skip_char(&s, 'x')){
continue;
}
address = atoh(s);
for(shift_cnt=0;shift_cnt<=16;shift_cnt++){
if(address == shift_bit){
printf("TCB_enatex_bit\tequ\t%d\n",shift_cnt);
fputs("TCB_enatex_bit\tequ\t", pfo);
sprintf(str,"%d",shift_cnt);
fputs(str, pfo);
fputs(lf, pfo);
}
shift_bit<<=1;
}
break;
default:
if(test_string(&s, "; BEGIN TCB_texptn")){
offset_state = TEXPTN_STATE;
continue;
}else if(test_string(&s, "; BEGIN TCB_sp")){
offset_state = SP_STATE;
continue;
}else if(test_string(&s, "; BEGIN TCB_pc")){
offset_state = PC_STATE;
continue;
}else if(test_string(&s, "; BEGIN TCB_enatex")){
offset_state = ENATEX_STATE;
continue;
}
break;
}
}
return 0;
}
