static int
is_reversible(int num)
{
int rev = reverse(num);
int sum = num + rev;
if(num_len(num)!=num_len(rev)) return 0;
while(sum > 0) {
int digit = sum % 10;
sum /= 10;
if(digit % 2 ==0) return 0;
}
return 1;
}
static int
dissect_beep_int(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf, int *val, int *hfa[])
{
proto_item *hidden_item;
int ival, ind = 0;
unsigned int i = num_len(tvb, offset);
guint8 int_buff[100];
memset(int_buff, '\0', sizeof(int_buff));
tvb_memcpy(tvb, int_buff, offset, MIN(sizeof(int_buff) - 1, i));
/* XXX - is this still "Dangerous" now that we don't copy to the
last byte of "int_buff[]"? */
if (sscanf((gchar*)int_buff, "%d", &ival) != 1)
ival = 0; /* Should we signal an error? */
if (tree) {
proto_tree_add_uint(tree, hf, tvb, offset, i, ival);
}
while (hfa[ind]) {
hidden_item = proto_tree_add_uint(tree, *hfa[ind], tvb, offset, i, ival);
PROTO_ITEM_SET_HIDDEN(hidden_item);
ind++;
}
*val = ival; /* Return the value */
return i;
}
static int num_len(uint32_t num) {
if (num < 10) {
return 1;
}
return 1 + num_len(num / 10);
}
int infix_parser(char *str, int *storage)
{
char *tmp = str;
int i, counter = 0;
while (*tmp) {
switch (*tmp) {
case '+':
case '-':
case '*':
case '/':
case '(':
case ')':
storage[counter++] = *tmp;
tmp += 1;
break;
default:
i = strtol(tmp, NULL, 10);
tmp += num_len(i);
storage[counter++] = i;
break;
}
}
return counter;
}
int num_len(int i)
{
if (i < 10)
return 1;
else
return 1 + num_len(i / 10);
}
static struct string *token_to_string(struct dyn_token *token) {
uint32_t num = token->mag[0];
int len = num_len(num);
struct string *result = dn_alloc(sizeof(*result));
string_init(result);
result->data = dn_alloc(sizeof(uint8_t) * len);
result->len = len;
string_write_uint32(result, num, result->len - 1);
return result;
}
char *ft_itoa(int n)
{
int len;
int sign;
char *nbr;
len = num_len(n);
if (!(nbr = ft_strnew(len)))
return (NULL);
sign = 1;
if (n < 0)
{
sign = -1;
nbr[0] = '-';
}
while (len-- >= 0)
{
nbr[len] = '0' + ((n % 10) * sign);
n /= 10;
if (len == 1 && sign < 0)
len = 0;
}
return (nbr);
}
/**
* @brief cmd_ps
* @param[in] void
* @param[in,out] void
* @return void
*/
void cmd_ps (void)
{
uint32_t i;
uint32_t len;
uint32_t task_free_size;
PRINT("\r\n");
PRINT("ID");
go_right(LINE_SPACE_01 - strlen("ID"));
PRINT("STACK_NAME");
go_right(LINE_SPACE_02 - strlen("STACK_NAME"));
PRINT("STASK_SIZE");
go_right(LINE_SPACE_03 - strlen("STASK_SIZE"));
PRINT("STASK_FREE");
go_right(LINE_SPACE_04 - strlen("STASK_FREE"));
PRINT("STATE");
PRINT("\r\n\r\n");
for (i = 0; i < bos_TaskCount; i++)
{
PRINT("%d", bos_TaskTable[i].task->task_id);
len = num_len(bos_TaskTable[i].task->task_id);
go_right(LINE_SPACE_01 - len);
PRINT("%s", bos_TaskTable[i].task->name);
len = strlen(bos_TaskTable[i].task->name);
go_right(LINE_SPACE_02 - len);
PRINT("%d", bos_TaskTable[i].task->stack_size);
len = num_len(bos_TaskTable[i].task->stack_size);
go_right(LINE_SPACE_03 - len);
task_free_size = task_free(i);
PRINT("%d", task_free_size);
len = num_len(task_free_size);
go_right(LINE_SPACE_04 - len);
switch (bos_TaskTable[i].task->flags)
{
case STATE_TERM:
PRINT("[T]"); // Terminated
break;
case STATE_READY:
PRINT("[R]"); // Ready
break;
case STATE_RUN:
PRINT("[A]"); // Active
break;
case STATE_WAIT:
PRINT("[W]"); // Wait
break;
default:
PRINT("[U]"); // Unknow
break;
}
PRINT("\r\n");
}
}
