/**********************************************************************
* AddProtoToClass
*
* Add a new proto to this class. Malloc new space and copy the
* old protos if necessary. Return the proto id for the new proto.
**********************************************************************/
int AddProtoToClass(CLASS_TYPE Class) {
int i;
int Bit;
int NewNumProtos;
int NewProto;
BIT_VECTOR Config;
if (Class->NumProtos >= Class->MaxNumProtos) {
/* add protos in PROTO_INCREMENT chunks at a time */
NewNumProtos = (((Class->MaxNumProtos + PROTO_INCREMENT) /
PROTO_INCREMENT) * PROTO_INCREMENT);
Class->Prototypes = (PROTO) Erealloc (Class->Prototypes,
sizeof (PROTO_STRUCT) *
NewNumProtos);
Class->MaxNumProtos = NewNumProtos;
for (i = 0; i < Class->NumConfigs; i++) {
Config = Class->Configurations[i];
Class->Configurations[i] = ExpandBitVector (Config, NewNumProtos);
for (Bit = Class->NumProtos; Bit < NewNumProtos; Bit++)
reset_bit(Config, Bit);
}
}
NewProto = Class->NumProtos++;
if (Class->NumProtos > MAX_NUM_PROTOS) {
tprintf("Ouch! number of protos = %d, vs max of %d!",
Class->NumProtos, MAX_NUM_PROTOS);
}
return (NewProto);
}
static int __set_gpio_value(uint32_t id, uint8_t pin_num, int value, uint32_t offset)
{
struct gpio_data *gpio_data = NULL;
uint32_t addr;
int width;
gpio_data = __get_gpio_data_by_id(id);
if (!gpio_data)
return -1;
addr = gpio_data->addr + offset;
switch(offset) {
case GPIO_MODER_OFFSET:
case GPIO_OSPEEDR_OFFSET:
case GPIO_PUPDR_OFFSET:
width = 2;
return set_value(addr, value, pin_num << 1, width);
case GPIO_AFRL_OFFSET:
case GPIO_AFRH_OFFSET:
width = 4;
return set_value(addr, value, (pin_num % 8) << 2, width);
default:
return (value)
? set_bit(addr, pin_num)
: reset_bit(addr, pin_num);
}
}
static int
free_bit(uint8_t bitmap[], size_t bits, size_t bit)
{
if (bit <= bits) {
reset_bit(bitmap, bit);
return 1;
}
return 0;
}
// Implements section 6.4.1, book 3 of EMV spec
int ProcessingRestrictions::CheckVersion()
{
int res;
if (InitStatus == EMV_DATA_ERROR)
return initError;
if (InitStatus == EMV_DATA_NOT_INITIALIZED)
{
if (initData() != SUCCESS)
return initError;
}
//1 Get an application version number read from the ICC
DataObject dob_icc;
res = EnvContext.getTagValue (0x9f08, &dob_icc, true);
if (res != SUCCESS || dob_icc.len == 0)
{
// If Appl Version number is not present in the ICC, simply return
return SUCCESS;
}
//2 Get an application version number from the terminal
DataObject dob_term;
res = EnvContext.getTagValue (0x9f09, &dob_term, false);
if (res != SUCCESS || dob_term.len == 0)
{
// If Appl Version number is not present on the terminal, simply return
return SUCCESS;
}
if (dob_icc.len != dob_term.len)
set_bit (dob_TVR.Data [1], 0x80); // Versions are different
else if (memcmp(dob_icc.Data, dob_term.Data, dob_icc.len) != 0)
set_bit (dob_TVR.Data [1], 0x80); // versions are different
else
{
// Versions are identical
reset_bit (dob_TVR.Data [1], 0x80);
}
// Update TVR
EnvContext.setTagValue (0x95, &dob_TVR, IO_UPDATE);
return SUCCESS;
}
static void hw_init(void)
{
reset_bit(GPIO_OE, 25);
reset_bit(GPIO_DATAOUT, 25);
}
void avaliador(AUTOMATO * automatos_inicio, b_vector N[]) {
AUTOMATO * atual_automato;
char literal[LITERAL_MAX_SIZE], lit_aux[LITERAL_MAX_SIZE], * ptr_aux;
int numero;
int node;
long seq_exec = 0;
long no_func_invoc = 0;
FILE * executed_paths = (FILE *) fopen("path.tes","r");
if (executed_paths == (FILE *) NULL) {
error("* * Erro Fatal: Nao consegui abrir o arquivo paths.tes * *");
}
/* algoritmo de avaliacao */
while (fscanf(executed_paths,"%d",&node) != EOF) { /* diferente de fim de arquivo */
/* controla a sequencia de execucao */
switch (node) {
case 0:
seq_exec = 0;
break;
case 1:
seq_exec = 1;
no_func_invoc++;
break;
default:
seq_exec++;
}
/* verifica os automatos */
for (atual_automato = automatos_inicio; atual_automato != (AUTOMATO *) NULL; atual_automato = atual_automato->next) {
if (atual_automato->estado == Q1 && node != 0) { /* esta' em processo de reconhecimento da expressao regular */
peg_tok(literal,atual_automato->pos_corrente);
/* verifica qual acao a ser tomada */
if ( !strcmp(literal, "N*")) { /* e' igual a N* */
peg_next_tok(lit_aux, atual_automato->pos_corrente);
if (lit_aux[0] == '\0') {
literal[0] = '\0'; /* nao existe proximo literal;
fim da expressao regular */
} else { /* existe proximo literal */
if (e_numero(lit_aux)) {
numero = atoi(lit_aux); /* converte ASCII para int */
if (node == numero) {
/* reconheceu o no'; caminha na expressao regular */
atual_automato->pos_corrente = jump_tok(atual_automato->pos_corrente);
} else {
if (! test_bit(node,&N[atual_automato->criterio])) {
atual_automato->estado = Q2; /* nao pertence a N; nao reconhece */
}
}
}
}
} else {
error("* * Erro Fatal: Descritor nao esta' correto * *");
}
if (! strcmp(literal,"Nnvlf*")) { /* e' igual a Nnvlf* */
peg_next_tok(lit_aux, atual_automato->pos_corrente);
if (lit_aux[0] == '\0') {
literal[0] = '\0'; /* nao existe proximo literal; fim da expressao regular */
if (atual_automato->estado == Q1) {
atual_automato->estado = Q3; /* reconheceu a entrada */
}
} else { /* existe proximo literal */
if (e_numero(lit_aux)) {
numero = atoi(lit_aux); /* converte ASCII para int */
if (node == numero) { /* reconheceu o no'; caminha na expressao regular */
atual_automato->pos_corrente = jump_tok(atual_automato->pos_corrente);
} else {
if (! test_bit(node,&(atual_automato->Nnv))) {
atual_automato->estado = Q2; /* nao pertence a N, nao reconhece */
}
}
}
}
} else {
error("* * Erro Fatal: Descritor nao esta' correto * *");
}
if (! strcmp(literal,"Nnv*")) { /* e' igual a Nnv* */
peg_next_tok(lit_aux,atual_automato->pos_corrente);
if (lit_aux[0] == '\0') {
literal[0] = '\0'; /* nao existe proximo literal; fim da expressao regular */
if (atual_automato->estado == Q1) {
atual_automato->estado = Q3; /* reconheceu a entrada */
}
} else { /* existe proximo literal */
if (e_numero(lit_aux)) {
numero = atoi(lit_aux); /* converte ASCII para int */
if (node == numero) {
/* reconheceu o no'; caminha na expressao regular */
atual_automato->pos_corrente = jump_tok(atual_automato->pos_corrente);
} else {
if (!test_bit(node, &(atual_automato->Nnv))) {
atual_automato->estado = Q2; /* nao pertence a N, nao reconhece */
}
}
} else {
error("* * Erro Fatal: Descritor nao esta' correto * *");
}
}
}
if (! strcmp(literal, "Nlf*")) { /* e' igual a Nlf* */
peg_next_tok(lit_aux,atual_automato->pos_corrente);
if (lit_aux[0] == '\0') {
literal[0] = '\0'; /* nao existe proximo literal; fim da expressao regular */
if (atual_automato->estado == Q1) {
atual_automato->estado = Q3; /* reconheceu a entrada */
}
} else { /* existe proximo literal */
if (e_numero(lit_aux)) {
numero = atoi(lit_aux); /* converte ASCII para int */
if (node == numero) {
/* reconheceu o no'; caminha na expressao regular */
atual_automato->pos_corrente = jump_tok(atual_automato->pos_corrente);
} else {
if (!test_bit(node,&(atual_automato->Nnv))) {
atual_automato->estado = Q2; /* nao pertence a N, nao reconhece */
}
}
} else {
error("* * Erro Fatal: Descritor nao esta' correto * *");
}
}
}
if (e_numero(literal)) { /* e' um numero */
numero = atoi(literal); /* converte ASCII para int */
if (numero == node) { /* reconheceu o no'; caminha na expressao regular */
atual_automato->pos_corrente = apont_next_tok(atual_automato->pos_corrente);
} else {
atual_automato->estado = Q2; /* nao reconheceu a entrada */
}
}
if (! strcmp(literal,"[")) {
/* faz ptr_aux apontar para o token "]" */
ptr_aux = apont_next_tok(jump_tok(atual_automato->pos_corrente));
peg_next_tok(lit_aux,ptr_aux);
if (lit_aux[0] == '\0') {
error("Erro Fatal: Expressao Regular errado no automato");
} else { /* existe proximo literal */
if (e_numero(lit_aux)) {
numero = atoi(lit_aux); /* converte ASCII para int */
if (node == numero) {
/* reconheceu o no'; caminha na expressao regular */
atual_automato->pos_corrente = jump_tok(ptr_aux);
} else {
if (!test_bit(node, &(atual_automato->Nnv))) {
atual_automato->estado = Q2; /* nao pertence a N, nao reconhece */
} else {
atual_automato->pos_corrente = apont_next_tok(atual_automato->pos_corrente);
}
}
} else {
error("* * Erro Fatal: Descritor nao esta' correto * *");
}
}
}
if (! strcmp(literal,"]*")) {
peg_next_tok(lit_aux, atual_automato->pos_corrente);
if (lit_aux[0] == '\0') {
error("Erro Fatal: Expressao Regular errado no automato");
} else { /* existe proximo literal */
if (e_numero(lit_aux)) {
numero = atoi(lit_aux); /* converte ASCII para int */
if (node == numero) { /* reconheceu o no'; caminha na expressao regular */
atual_automato->pos_corrente = jump_tok(atual_automato->pos_corrente);
} else {
if (!test_bit(node, &(atual_automato->Nnv))) {
atual_automato->estado = Q2; /* nao pertence a N, nao reconhece */
} else {
atual_automato->pos_corrente = apont_prev_tok(apont_prev_tok(atual_automato->pos_corrente));
}
}
} else {
error("* * Erro Fatal: Descritor nao esta' correto * *");
}
}
}
if (atual_automato->estado == Q3 || (atual_automato->estado == Q1 && fim_exp_reg(atual_automato->pos_corrente))) {
/* registra a frequencia */
atual_automato->estado = Q1;
atual_automato->freq++;
atual_automato->pos_corrente = atual_automato->exp_regular;
if (atual_automato->i == node) {
atual_automato->pos_corrente = jump_tok(atual_automato->exp_regular);
}
if (atual_automato->criterio != PU && atual_automato->criterio != ARCS && atual_automato->criterio != NOS) {
/* atual_automato->Nnv = atual_automato->Ni; */
b_vector_cpy(&(atual_automato->Nnv),&(atual_automato->Ni));
}
}
}
if (atual_automato->estado == Q2 && atual_automato->i == node) { /* "reseta" o automato */
atual_automato->estado = Q1;
atual_automato->pos_corrente = jump_tok(atual_automato->exp_regular);
/* se o criterio nao e todos-pot-usos, recupera o conjunto Nnv */
if (atual_automato->criterio != PU && atual_automato->criterio != ARCS && atual_automato->criterio != NOS) {
/* atual_automato->Nnv = atual_automato->Ni; */
b_vector_cpy(&(atual_automato->Nnv),&(atual_automato->Ni));
}
}
switch (atual_automato->freq) {
case 0:
/* Primeira ocorrencia do automato, guarda a sequencia de execucao do no i */
if (atual_automato->i == node) {
atual_automato->seq_exec_i = seq_exec;
}
break;
case 1:
/* Primeira ocorrencia do automato, guarda a sequencia de execucao do no j */
if (atual_automato->seq_exec_j == 0) {
atual_automato->seq_exec_j = seq_exec;
atual_automato->no_func_invoc = no_func_invoc;
}
break;
default:
/* Ja' foi registrada a primeira ocorrencia da associacao */
break;
}
/* se o criterio nao e todos-pot-usos, retira o no do conjunto Nnv */
if ((atual_automato->criterio == PDU && atual_automato->criterio == PUDU) && atual_automato != (AUTOMATO *) NULL && strcmp(literal,"N*")) {
reset_bit(node,&(atual_automato->Nnv));
}
}
}
/* terminou de avaliar um caso de teste agora ajusta automatos */
for (atual_automato = automatos_inicio;atual_automato != (AUTOMATO *) NULL; atual_automato = atual_automato->next) {
if (atual_automato->freq == 0) { /* nao reconheceu a entrada */
atual_automato->estado = Q1;
atual_automato->pos_corrente = atual_automato->exp_regular;
} else {
if (atual_automato->freq > 0) {
atual_automato->estado = Q3; /* reconheceu a entrada */
tot_req_exec[atual_automato->criterio] += atual_automato->freq;
}
}
}
fclose(executed_paths);
return;
}
