Ejemplo n.º 1
0
 Stack* Recorrer(Maze *m, Point *input){
 	int i;
 	Stack *paux = NULL; /*pila auxiliar*/
 	Stack *pcamino = NULL; /*pila del camino seguido*/
 	EleStack *pele = NULL; /*punto donde nos encontramos*/
 	EleStack *pelepoint = NULL; /*Punto vecino*/
 	Point *ppoint = NULL;
 	Point *ppoint2 = NULL;
 	if(!m){
 		printf("Error pasando el maze\n");
 		return NULL;
 	}
 	if(!input){
 		printf("Error pasando el input\n");
 		return NULL;
 	}
 	paux = stack_ini();
 	if (!paux){
 		printf ("Error en reserva memoria paux\n");
 		return NULL;
 	}
 	pcamino = stack_ini();
 	if (!pcamino){
 		printf ("Error reserva memoria pcamino\n");
 		stack_free (paux);
 		return NULL; 
 	}
 	pele = elestack_ini();
 	if (!pele){
 		printf ("Error reserva memoria pele\n");
 		stack_free(paux);
 		stack_free(pcamino);
 		return NULL;
 	}
 	if (!elestack_setInfo(pele, input)){ /*Guardamos el punto input en pele*/
 		printf ("Error en setInfo de pele\n");
 		elestack_free(pele);
 		stack_free(paux);
 		stack_free(pcamino);
 		return NULL;
 	}
 	if(!stack_push (paux, pele)){ /*Introducimos pele en la pila auxiliar*/
 		printf("Error push del input\n");
 		elestack_free(pele);
 		stack_free(paux);
 		stack_free(pcamino);
 		return NULL;
 	}
 	elestack_free(pele); 
 	while (!stack_isEmpty(paux)){ /*mientras la pila auxiliar no esta vacia*/
 		pele = stack_pop(paux); /*extraemos el punto superior de la pila y nos "situamos" ahi*/
 		stack_push(pcamino, pele); /*Como visitamos ese punto lo introducimos en el camino*/
 		point_setSymbol(maze_getPoint(m, point_getCoordinateX((Point *)elestack_getInfo(pele)), point_getCoordinateY((Point *)elestack_getInfo(pele))), VISITADO);
 		/*Modificamos el simbolo del punto a VISITADO, lo guardamos en el laberinto original*/

		
		for(i = 0; i <= DOWN; i++){ /*Comprobamos las 4 direcciones que se pueden seguir dentro de un laberinto*/
			pelepoint = elestack_ini();
			if(!pelepoint){
				printf("Error en elestack_ini\n");
				elestack_free(pele);
	 			stack_free(paux);
	 			stack_free(pcamino);
 			return NULL;
			}
			ppoint2 = (Point*)elestack_getInfo(pele); /*Obtenemos el punto de pele*/
			if(!ppoint2){
				printf("Error al obtener el punto de pele");
				elestack_free(pelepoint);
	 			elestack_free(pele);
	 			stack_free(paux);
	 			stack_free(pcamino);
	 			return NULL;
			}
			ppoint = maze_getNeighborPoint(m, ppoint2, i); /*Obtenemos el punto vecino en la direccion que indica "i"*/
			if(!ppoint){
				printf("Error ppoint 1\n");
				elestack_free(pelepoint);
	 			elestack_free(pele);
	 			stack_free(paux);
	 			stack_free(pcamino);
	 			return NULL;
			}
			if(!elestack_setInfo(pelepoint, (void*)ppoint)){ /*Asignamos a pelepoint el punto vecino*/
				printf("Error setinfo\n");
				elestack_free(pelepoint);
	 			elestack_free(pele);
	 			stack_free(paux);
	 			stack_free(pcamino);
	 			return NULL;
			}
			if(point_getSymbol(ppoint) == SPACE){ /*Introducimos el punto en la pila auxiliar SOLO si es un SPACE*/
				if(!stack_push(paux, pelepoint)){
					printf("Error al hacer el push de pelepoint");
					elestack_free(pelepoint);
		 			elestack_free(pele);
		 			stack_free(paux);
		 			stack_free(pcamino);
		 			return NULL;
				}
			}
			else if(point_getSymbol(ppoint) == OUTPUT){ /*Si el punto es el OUTPUT, lo introduce en el camino y devuelve dicha pila*/
				stack_push(pcamino, pelepoint);
				elestack_free(pelepoint);
				elestack_free(pele);
				stack_free(paux);
				return pcamino;
			}
			elestack_free(pelepoint);
		}
 		
 		elestack_free(pele);
 	}
 	stack_free(paux);
 	stack_free(pcamino);
	return NULL;
 }
Ejemplo n.º 2
0
Archivo: daemon.c Proyecto: qnaal/fls
static bool daemon_serve(int s, char *cmd) {
  /* Do <cmd> for client connected on <s>. */
  static Node *null=NULL, **stack=&null;
  char buf[FILEPATH_MAX];
  bool keep_running=true;

  if( strcmp(cmd, CMD_PUSH) == 0 ) {
    char *status;
    if( stack_len(stack) >= STACK_MAX ) {
      printf("daemon: push request failed (stack full)\n");
      status = MSG_ERROR;
      strcpy(buf, MSG_ERR_STACK_FULL);
    } else {
      soc_w(s, MSG_SUCCESS);
      if( soc_r(s, buf, FILEPATH_MAX) <= 0 ) {
	printf("daemon: push request failed (read error)\n");
	status = MSG_ERROR;
	strcpy(buf, MSG_ERR_LENGTH);
      } else {
	status = MSG_SUCCESS;
	stack_push(buf, stack);
	printf("daemon: PUSH `%s'\n", buf);
      }
    }
    soc_w(s, status);
    soc_w(s, buf);

  } else if( strcmp(cmd, CMD_POP) == 0 ) {
    char *status;
    if( stack_len(stack) > 0 ) {
      status = MSG_SUCCESS;
      sprintf(buf, "%s", stack_peek(stack));
      stack_drop(stack);
      printf("daemon: POP `%s'\n", buf);
    } else {
      printf("daemon: tried to pop from empty stack\n");
      status = MSG_ERROR;
      sprintf(buf, MSG_ERR_STACK_EMPTY);
    }
    soc_w(s, status);
    soc_w(s, buf);

  } else if( strcmp(cmd, CMD_PEEK) == 0 ) {
    char *status;
    if( stack_len(stack) > 0 ) {
      status = MSG_SUCCESS;
      sprintf(buf, "%s", stack_peek(stack));
    } else {
      status = MSG_ERROR;
      sprintf(buf, MSG_ERR_STACK_EMPTY);
    }
    soc_w(s, status);
    soc_w(s, buf);

  } else if( strcmp(cmd, CMD_PICK) == 0 ) {
    char *picked;
    soc_w(s, MSG_SUCCESS);
    soc_r(s, buf, MSG_MAX);
    picked = stack_nth(atoi(buf), stack);
    if( picked == NULL ) {
      soc_w(s, MSG_ERROR);
      soc_w(s, "stack is not quite that deep");
    } else {
      soc_w(s, MSG_SUCCESS);
      soc_w(s, picked);
    }

  } else if( strcmp(cmd, CMD_SIZE) == 0 ) {
    sprintf(buf, "%d", stack_len(stack));
    soc_w(s, buf);

  } else if( strcmp(cmd, CMD_STOP) == 0 ) {
    printf("daemon: Shutting down...\n");
    soc_w(s, MSG_SUCCESS);
    keep_running = false;

  } else {
    char msg[MSG_MAX + FILEPATH_MAX];
    sprintf(msg, "unknown command `%s'", cmd);
    soc_w(s, msg);
  }

  return keep_running;
}
Ejemplo n.º 3
0
void append_call_stack_tabled(char type, obj_table* table){
    obj * o = create_call_block_tabled(type, call_stack_top, table);
    stack_push(call_stack, o);
    call_stack_top = (call_block*)o->data;
}
Ejemplo n.º 4
0
/*
 * input: rule straight from the DDDS + avp-stack.
 *
 * output: adds found rules to the stack and return
 * 	1 on success
 * 	0 on failure
 */
static int check_rule(str *rule, char *service, int service_len, struct avp_stack *stack) {

    /* for the select */
    db_key_t keys[2];
    db_val_t vals[2];
    db_key_t cols[4]; 
    db1_res_t* res;
    db_row_t* row;
    db_val_t* val;
    int	i;
    char *type;
    int type_len;

    LM_INFO("checking for '%.*s'.\n", rule->len, ZSW(rule->s));

    if ((service_len != 11) || (strncasecmp("d2p+sip:fed", service, 11) && 
	    strncasecmp("d2p+sip:std", service, 11)  && strncasecmp("d2p+sip:dom", service, 11))) {
    	LM_ERR("can only cope with d2p+sip:fed, d2p+sip:std,and d2p+sip:dom "
				"for now (and not %.*s).\n", service_len, service);
	return(0);
    }

    type = service + 8;
    type_len = service_len - 8;

    if (domainpolicy_dbf.use_table(db_handle, &domainpolicy_table) < 0) {
	    LM_ERR("failed to domainpolicy table\n");
	    return -1;
    }

    keys[0]=&domainpolicy_col_rule;
    keys[1]=&domainpolicy_col_type;
    cols[0]=&domainpolicy_col_rule;
    cols[1]=&domainpolicy_col_type;
    cols[2]=&domainpolicy_col_att;
    cols[3]=&domainpolicy_col_val;

    VAL_TYPE(&vals[0]) = DB1_STR;
    VAL_NULL(&vals[0]) = 0;
    VAL_STR(&vals[0]).s = rule->s;
    VAL_STR(&vals[0]).len = rule->len;

    VAL_TYPE(&vals[1]) = DB1_STR;
    VAL_NULL(&vals[1]) = 0;
    VAL_STR(&vals[1]).s = type;
    VAL_STR(&vals[1]).len = type_len;

    /*
     * SELECT rule, att, val from domainpolicy where rule = "..."
     */

    if (domainpolicy_dbf.query(db_handle, keys, 0, vals, cols, 2, 4, 0, &res) < 0
		    ) {
	    LM_ERR("querying database\n");
	    return -1;
    }
    
    LM_INFO("querying database OK\n");

    if (RES_ROW_N(res) == 0) {
	    LM_DBG("rule '%.*s' is not know.\n", 
		rule->len, ZSW(rule->s));
	    domainpolicy_dbf.free_result(db_handle, res);
	    return 0;
    } else {
	    LM_DBG("rule '%.*s' is known\n", rule->len, ZSW(rule->s));

	    row = RES_ROWS(res);

	    for(i = 0; i < RES_ROW_N(res); i++) {
			if (ROW_N(row + i) != 4) {
	    	    LM_ERR("unexpected cell count\n");
				return(-1);
			}

			val = ROW_VALUES(row + i);

			if ((VAL_TYPE(val) != DB1_STRING) || 
				(VAL_TYPE(val+1) != DB1_STRING) ||
				(VAL_TYPE(val+2) != DB1_STRING) ||
				(VAL_TYPE(val+3) != DB1_STRING)) {
					LM_ERR("unexpected cell types\n");
			    return(-1);
			}

			if (VAL_NULL(val+2) || VAL_NULL(val+3)) {
				LM_INFO("db returned NULL values. Fine with us.\n");
				continue;
			}

			LM_INFO("DB returned %s/%s \n",VAL_STRING(val+2),VAL_STRING(val+3));


			if (!stack_push(stack, (char *) VAL_STRING(val+2), 
					(char *) VAL_STRING(val+3))) {
			    return(-1);
			}
	    }
	    domainpolicy_dbf.free_result(db_handle, res);
	    return 1;
    }
}
Ejemplo n.º 5
0
int main(int argc, char* argv[])
{
	int i;
	node * m;

	/* obligatory */
	printf("Hello, World\r\n");
	printf("\r\n---\r\n");

	/* Node stuff */

	printf("Creating and destroying 10000 nodes\r\n");
	for (i = 0; i < 10000 ; i++)
	{
		int data = i;
		node * n = build_node(&data);
		destroy_node(n);
	}
	printf("Done\r\n");

	printf("\r\n---\r\n");

	printf("Building a queue, adding 10000 nodes. Printing out every 1000\r\n");
	queue * q = build_queue();

	for (i = 0; i < 10000 ; i++)
	{
		int data = i;
		node * n = build_node(&data);
		queue_push(q, n);
	}
	printf("Queue has the size %d\r\n", q->size);

	for (i = 0; i < 10000 ; i++)
	{
		node * n = queue_pop(q);
		if((i%1000)==0)
		{
			printf("Node has the data %d\r\n", *(int*)n->data);
		}
		destroy_node(n);
	}
	printf("Queue has the size %d\r\n", q->size);

	destroy_queue(q);
	printf("\r\n---\r\n");

	printf("Building a stack, adding 10000 nodes. Printing out every 1000\r\n");
	stack * s = build_stack();

	for (i = 0; i < 10000 ; i++)
	{
		int data = i;
		node * n = build_node(&data);
		stack_push(s, n);
	}
	printf("Stack has the size %d\r\n", s->size);

	for (i = 0; i < 10000 ; i++)
	{
		node * n = stack_pop(s);
		if((i%1000)==0)
		{
			printf("Node has the data %d\r\n", *(int*)n->data);
		}
		destroy_node(n);
	}
	printf("Stack has the size %d\r\n", s->size);

	destroy_stack(s);
	printf("\r\n---\r\n");
	
	printf("Building a linked list, adding 10000 nodes. Printing out every 1000\r\n");
	llist * l = build_llist();

	for (i = 0; i < 10000 ; i++)
	{
		int data = i;
		node * n = build_node(&data);
		llist_add(l, n);
	}
	printf("llist has the size %d\r\n", l->size);
	
	printf("Testing arbitrary access...\r\n");
	m = llist_get(l, 87);
  printf("Node has the data %d\r\n", *(int*)m->data);
  m = llist_get(l, 3487);
  printf("Node has the data %d\r\n", *(int*)m->data);
  m = llist_get(l, 287);
  printf("Node has the data %d\r\n", *(int*)m->data);
  
  printf("Testing arbitrary delete...\r\n");
  
  m = llist_get(l, 299);
  printf("Node has the data %d\r\n", *(int*)m->data);
  llist_delete(l, 299);
  m = llist_get(l, 299);
  printf("Node has the data %d\r\n", *(int*)m->data);

	printf("Testing mass delete...\r\n");
	destroy_llist(l);
	
	printf("\r\n---\r\n");
	
	printf("Creating and destroying 10000 single trees\r\n");
	for (i = 0; i < 10000 ; i++)
	{
		int data = i;
		tree * n = build_tree(&data);
		destroy_tree(n);
	}
	printf("Done\r\n");

	printf("\r\n---\r\n");
	
	printf("Testing add/delete for trees\r\n");
	int data = 2;
	tree * root = build_tree(&data);
	
	//for (i = 0; i < 3 ; i++)
//	{
//		int data = i;
//		tree * n = build_tree(&data);
//		destroy_tree(n);
//		add_leaf(&root, n, &tree_int_comp);
//	}
	
	data = 1;
	tree * leaf1 = build_tree(&data);
	add_leaf(&root, leaf1, &tree_int_comp);
	
	data = 0;
	tree * leaf2 = build_tree(&data);
	add_leaf(&root, leaf2, &tree_int_comp);
	
	printf("Root node has value %d before deletion\r\n", *(int*)root->data);
	delete_node(&(root));
	printf("Root node has value %d after deletion\r\n", *(int*)root->data);
	
	destroy_tree(leaf1);
	destroy_tree(leaf2);
	
	printf("Done\r\n");

	return 0;
}
Ejemplo n.º 6
0
//中間の数式を逆ポーランドに変換する関数
void convert_in_formula_to_rpn_formula(char* formula)
{
	printf("\tConvert IN Formula to RPN Formula : start IN Formula = \"%s\"\n",formula);

	char tmp_buffer[BUFFER_LENGTH];
	int tmp_buffer_pointer = 0;
	string_clear(tmp_buffer,'\0',BUFFER_LENGTH);

	int i;

	//メインループ
	for(i=0;formula[i]!='\0';i++)
	{
		//数字の処理
		if((formula[i]>='0'&&formula[i]<='9')||formula[i]=='.')
		{
			tmp_buffer[tmp_buffer_pointer++] = formula[i];
		}
		//各演算子の処理
		else if(formula[i]=='+')
		{
			for(;;)
			{
				//自分の優先順位より低くなるまでスタックをポップ
				if((int)(stack_pointer-1)>=0)
				{
					if((int)stack[stack_pointer-1]!='(')
					{
						tmp_buffer[tmp_buffer_pointer++] = ' ';
						tmp_buffer[tmp_buffer_pointer++] = (int)stack_pop();
					}
					else
					{
						stack_push(formula[i]);
						break;
					}
				}
				else
				{
					stack_push(formula[i]);
					break;
				}
			}
			tmp_buffer[tmp_buffer_pointer++] = ' ';
		}
		else if(formula[i]=='-')
		{
			//式の最初にマイナスがあったときのための処理
			if(i==0)
			{
				tmp_buffer[tmp_buffer_pointer++] = '0';
				tmp_buffer[tmp_buffer_pointer++] = ' ';
			}
			else if(formula[i-1]=='(')
			{
				tmp_buffer[tmp_buffer_pointer++] = '0';
				tmp_buffer[tmp_buffer_pointer++] = ' ';
			}

			for(;;)
			{
				//自分の優先順位より低くなるまでスタックをポップ
				if((stack_pointer-1)>=0)
				{
					if((int)stack[stack_pointer-1]!='+'&&(int)stack[stack_pointer-1]!='(')
					{
						tmp_buffer[tmp_buffer_pointer++] = ' ';
						tmp_buffer[tmp_buffer_pointer++] = (int)stack_pop();
					}
					else
					{
						stack_push(formula[i]);
						break;
					}
				}
				else
				{
					stack_push(formula[i]);
					break;
				}
			}
			tmp_buffer[tmp_buffer_pointer++] = ' ';
		}
		else if(formula[i]=='*')
		{
			for(;;)
			{
				//自分の優先順位より低くなるまでスタックをポップ
				if((stack_pointer-1)>=0)
				{
					if((int)stack[stack_pointer-1]!='+'&&(int)stack[stack_pointer-1]!='-'&&(int)stack[stack_pointer-1]!='(')
					{
						tmp_buffer[tmp_buffer_pointer++] = ' ';
						tmp_buffer[tmp_buffer_pointer++] = (int)stack_pop();
					}
					else
					{
						stack_push(formula[i]);
						break;
					}
				}
				else
				{
					stack_push(formula[i]);
					break;
				}
			}
			tmp_buffer[tmp_buffer_pointer++] = ' ';
		}
		else if(formula[i]=='/')
		{
			for(;;)
			{
				//自分の優先順位より低くなるまでスタックをポップ
				if((stack_pointer-1)>=0)
				{
					if((int)stack[stack_pointer-1]!='+'&&(int)stack[stack_pointer-1]!='-'&&(int)stack[stack_pointer-1]!='*'&&(int)stack[stack_pointer-1]!='(')
					{
						tmp_buffer[tmp_buffer_pointer++] = ' ';
						tmp_buffer[tmp_buffer_pointer++] = (int)stack_pop();
					}
					else
					{
						stack_push(formula[i]);
						break;
					}
				}
				else
				{
					stack_push(formula[i]);
					break;
				}
			}
			tmp_buffer[tmp_buffer_pointer++] = ' ';
		}
		//括弧開きがあったとき
		else if(formula[i]=='(')
		{
			stack_push(formula[i]);
			tmp_buffer[tmp_buffer_pointer++] = ' ';
		}
		//括弧閉じがあったとき
		else if(formula[i]==')')
		{
			for(;;)
			{
				//括弧開きが出るまでスタックをポップ
				if(stack[stack_pointer-1]!='(')
				{
					tmp_buffer[tmp_buffer_pointer++] = ' ';
					tmp_buffer[tmp_buffer_pointer++] = (int)stack_pop();
				}
				//括弧開きは読み捨てる
				else
				{
					stack_pop();
					break;
				}
			}
		}
	}

	//スタックに残っている演算子をすべてポップ
	for(i=stack_pointer-1;i>=0;i--)
	{
		tmp_buffer[tmp_buffer_pointer++] = ' ';
		tmp_buffer[tmp_buffer_pointer++] = (int)stack_pop();
	}
	tmp_buffer[tmp_buffer_pointer++] = '\0';

	my_strcpy(formula,tmp_buffer);

	string_clear(tmp_buffer,'\0',BUFFER_LENGTH);
	tmp_buffer_pointer = 0;
	stack_clear();

	printf("\tConvert IN Formula to RPN Formula : done  RPN Formula = \"%s\"\n",formula);
}
Ejemplo n.º 7
0
static int
push(struct eval *eval, struct tok *tok)
{
	return stack_push(eval->opstk, tok);
}
Ejemplo n.º 8
0
Archivo: buffer.c Proyecto: kaye64/gem
/**
 * Stores the current read and write pointers
 */
void buffer_pushp(buffer_t* buffer)
{
	stack_push(&buffer->ptr_stack, buffer->read_ptr);
	stack_push(&buffer->ptr_stack, buffer->read_avail);
}
Ejemplo n.º 9
0
/* @builtin-bind { '"', builtin_string }, */
int builtin_string(interpreter* interp) {
  string accum, s;
  int result;
  unsigned begin;

  accum = empty_string();
  ++interp->ip;
  while (1) {
    /* Scan for the next important character. */
    for (begin = interp->ip; is_ip_valid(interp); ++interp->ip)
      if (curr(interp) == '"' ||
          curr(interp) == '$' ||
          curr(interp) == '`' ||
          curr(interp) == '\\' ||
          curr(interp) == '%')
        break;

    /* Found important character or EOI. */
    if (!is_ip_valid(interp)) {
      print_error("Encountered end-of-input in string literal");
      goto error;
    }

    /* Append everything in-between */
    accum = append_data(accum,
                        string_data(interp->code) + begin,
                        string_data(interp->code) + interp->ip);

    switch (curr(interp)) {
    case '"': goto done;
    case '$':
      ++interp->ip;
      if (!is_ip_valid(interp)) {
        print_error("Encountered end-of-input in string literal");
        goto error;
      }
      /* Append value of this register */
      accum = append_string(accum,
                            interp->registers[curr(interp)]);
      touch_reg(interp, curr(interp));
      break;

    case '%':
      s = stack_pop(interp);
      if (!s) {
        print_error("Stack underflow");
        goto error;
      }
      accum = append_string(accum, s);
      free(s);
      break;

    case '`':
      if (!interp->initial_whitespace) {
        print_error("Initial whitespace (`) not available in this context.");
        goto error;
      }
      accum = append_string(accum, interp->initial_whitespace);
      break;

    case '\\':
      result = builtin_escape(interp);
      if (!result) goto error;
      if (result == 2) break; /* Didn't push anything */
      s = stack_pop(interp);
      /* Popping will always succeed if escape returned success. */
      accum = append_string(accum, s);
      free(s);
      break;
    }

    /* All the above (which don't goto elsewhere) leave the IP on the end of
     * whatever special thing they did.
     */
    ++interp->ip;
  }

  done:
  stack_push(interp, accum);
  return 1;

  error:
  diagnostic(interp, NULL);
  free(accum);
  return 0;
}
Ejemplo n.º 10
0
int primary_expression_mods(struct token *token)
{
    printf("Hello from primary_expression_mods\n");
    if (token->op_type == OPENPAREN){
        tree_mknode(-1); //TODO implement '('
        input_consume();
        free_token(token);
        stack_pop();
        stack_push(TOKEN_CLOSEPAREN); //')'
        stack_push(PRIMARY_EXPRESSION_LIST);
        return -1;
    }
    else if (token->op_type == OPENBRACKET){
        tree_mknode(PRIMARY_EXPRESSION_MODS);
        input_consume(); //get the [
        free_token(token);
        stack_pop();
        struct token *t = input_consume(); //the inner part of the [x]

        struct identifier *nid = malloc(sizeof(struct identifier));
        nid->lexeme = t->lexeme;
        if (t->type == ID_KW){
            struct hashentry *he = hash_retrieve(kwtable, nid->lexeme);
            if (he != NULL){ //is a keyword (an error)
                log_error(PRIMARY_EXPRESSION_MODS);
                return -1;
            }
            else{
                he = hash_retrieve(symboltable, nid->lexeme);
                if (he == NULL){ //symbol not defined
                    log_error(PRIMARY_EXPRESSION_MODS);
                    printf("%s has not been initialized\n", nid->lexeme);
                    return -1;
                }
                else{
                    tree_add_attr(he->data, 4);
                    free_token(t);
                    input_consume();    //the last ]
                    return 0;
                }
            }
        }
        else if (t->type >= C_NUM && t->type <= C_F){
            struct identifier *id = malloc(sizeof(struct identifier));
            id->lexeme = t->lexeme;
            type_const(id->type);
            tree_add_attr(id, 4); //add it as attribute
            free(t);
            input_consume(); // the last ]
            return 0;
        }
        else{
            log_error(PRIMARY_EXPRESSION_MODS);
            printf("%s has not been initialized\n", nid->lexeme);
            return -1;
        }
    }
    else if (token->op_type == VALUEAT){
        input_consume(); // throw away '.'
        struct token *tmp = input_consume(); //get the identifier
        struct hashentry *ifkw = hash_retrieve(kwtable, tmp->lexeme);
        if (ifkw != NULL){ //error is a keyword
            log_error(PRIMARY_EXPRESSION_MODS);
            return -1;
        }
        else{
            tree_mknode(-1); //TODO implement '.'
            free_token(token);
            stack_pop();
            stack_push(PRIMARY_EXPRESSION);
            return -1;
        }
    }
    else{ //not a mod of a primary expression
        stack_pop();
        return 0;
    }
}
Ejemplo n.º 11
0
 inline void r_store_stack(CF, R0) {
   stack_push(RVAL(r0));
 }
Ejemplo n.º 12
0
int binary_op(struct token *token)
{
    switch (token->op_type){

    case LOGOR:
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(LOGICAL_OR_EXPRESSION);
        return 0;
    case LOGAND:
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(LOGICAL_AND_EXPRESSION);
        return 0;
    case BWOR:
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(INCLUSIVE_OR_EXPRESSION);
        return 0;
    case BWXOR:
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(EXCLUSIVE_OR_EXPRESSION);
        return 0;
    case BWAND:
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(AND_EXPRESSION);
        return 0;
    case EQUALS: case NOTEQUALS:
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(EQUALITY_EXPRESSION);
        return 0;
    case LT: case LE: case GT: case GE:
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(RELATIONAL_EXPRESSION);
        return 0;
    case SHIFTLEFT: case SHIFTRIGHT: 
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(SHIFT_EXPRESSION);
        return 0;
    case PLUS: case MINUS:                    // + -
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(ADDITIVE_EXPRESSION);
        return 0;
    case MULTIPLY: case DIVIDE: case MODULO:       // * / %
        tree_mknode(BINARY_OP);
        stack_pop();
        stack_push(MULTIPLICATIVE_EXPRESSION);
        return 0;
    case EOE: //direct expression
        //tree_mknode(BINARY_OP);
        //tree_add_attr(token, -1);
        stack_pop(); //pop the binary op
        stack_pop(); //pop the second lrvalue
        return 0;
    default:
        log_error(BINARY_OP);
        return -1;
    }
}
Ejemplo n.º 13
0
int jump_statement(struct token *token)
{
    printf("Hello from jump_statement\n");//DEBUG
    // goto label conditional
    if( strncmp("goto", token->lexeme, 4) == 0){
        tree_mknode(JUMP_STATEMENT);
        input_consume(); //consume the goto
        free_token(token);
        struct token *label = input_consume();
        struct token *conditional = input_consume();
        if (label->type == ID_KW){
            struct hashentry *ifkw = hash_retrieve(kwtable, label->lexeme);
            if (ifkw == NULL){//not a keyword, an identifier

                struct hashentry *predefined;
                struct hashentry *predefined2;

                //get symboltable entry for label
                predefined = hash_retrieve(symboltable, label->lexeme);
                if(predefined == NULL){
                    predefined = malloc(sizeof(struct hashentry));
                    predefined->data = malloc(sizeof(struct identifier));
                    predefined->data->lexeme = label->lexeme;
                    type_id(predefined->data->type);
                    //log_error(LABELED_STATEMENT);
                    //printf("Symbol: %s has not been defined!\n", label->lexeme);
                    //return -1;
                }
                //get symboltable entry for conditional
                predefined2 = hash_retrieve(symboltable, conditional->lexeme);
                if(predefined2 == NULL){
                    log_error(LABELED_STATEMENT);
                    printf("Symbol: %s has not been defined!\n", conditional->lexeme);
                    return -1;
                }

                struct hashentry *gokw = hash_retrieve(kwtable, "goto");

                tree_add_attr(gokw->data, 0);
                tree_add_attr(predefined->data, 1);
                tree_add_attr(predefined2->data, 2);

                printf("Consumed: goto %s %s\n", 
                    label->lexeme, conditional->lexeme);//DEBUG
                stack_pop();
                stack_push(TOKEN_ENDSTATEMENT);
                free(label);
                free(conditional);
                return 0;
            }
            else{
                log_error(JUMP_STATEMENT);
                free_token(label);
                free_token(conditional);
                return -1;
            }
        }
        else{
            printf("Incorrect goto label: %s\n", label->lexeme);//DEBUG
            free_token(label);
            free_token(conditional);
            log_error(JUMP_STATEMENT);
            return -1;
        }
    }
    else{
        log_error(JUMP_STATEMENT);
        return -1;
    }
}
Ejemplo n.º 14
0
/*
 * Print Binary Search Tree in inorder fashion without using recursion.
 *
 * @cur_root : Root of the Binary Search Tree.
 */
void bst_print_inorder_nonrecur(node_t *cur_root)
{
    /* Stack of nodes that we have visited but yet to process their left sub-tree. */
    Stack_t nodes_stack;
    /* Stack of childrens of nodes in the above stack which are yet to be visited. */
    Stack_t childs_stack;

    stack_init(&nodes_stack);
    stack_init(&childs_stack);

    if (!cur_root)
    {
        //NO-OP.
        return;
    }

    /* we have just visited root's parent :). */
    stack_push(&childs_stack, cur_root);

    while (!stack_empty(&childs_stack) || !stack_empty(&nodes_stack))
    {
        if (!stack_empty(&childs_stack))
        {
            node_t *child = (node_t *) stack_pop(&childs_stack);
            assert(child);

            if (child->left_child)
            {
                /* As this is inorder we need to process left sub-tree first. */
                stack_push(&childs_stack, child->left_child);
                /* Once left sub-tree is prcessed we can process its parent then. */
                stack_push(&nodes_stack, child);
            }
            else
            {
                //Done with left sub-tree.
                printf("%d ", child->data);

                if (child->right_child)
                {
                    stack_push(&childs_stack, child->right_child);
                }
            }
        }
        else
        {
            assert(!stack_empty(&nodes_stack));
            node_t *node = (node_t *) stack_pop(&nodes_stack);
            assert(node);

            //Done with left sub-tree.
            printf("%d ", node->data);

            if (node->right_child)
            {
                stack_push(&childs_stack, node->right_child);
            }
        }
    }

    assert(stack_empty(&nodes_stack) && stack_empty(&childs_stack));
}
Ejemplo n.º 15
0
int main(int argc, char *argv[])
{
	char command[32];
	int eventsNr, eventId, procId, priority;
	int i, iteration;
	TStack **eventsStacks;
	TQueue *procQ;

	// Daca nu exista destule argumente la rularea programului, atunci opreste executia
	if (argc < 3)
	{
		printf("Argumente insuficiente!\n");
		return -1;
	}

	// Seteaza fisierele de intrare si de iesire
	freopen(argv[1], "r", stdin);
	freopen(argv[2], "w", stdout);

	// Citeste numarul de event-uri si creeaza stivele lor
	fscanf(stdin, "%d", &eventsNr);

	eventsStacks = calloc(eventsNr,  sizeof(TStack*));
	for (i = 0; i < eventsNr; i++)
	{
		eventsStacks[i] = stack_new(sizeof(TProcess));
	}

	// Creeaza coada de prioritati
	procQ = queue_new(sizeof(TProcess), compare_process);

	// Citeste si executa comenzile din fisierul de intrare
	iteration = 0;

	while (fscanf(stdin, "%s", command) != EOF)
	{
		iteration++;

		if (strcmp(command, "start") == 0)
		{
			fscanf(stdin, "%d", &procId);
			fscanf(stdin, "%d", &priority);

			// Creeaza un proces
			TProcess p;
			p.id = procId;
			p.priority = priority;
			p.iteration = iteration;

			// Introduce procesul creat in coada de prioritati
			queue_push(procQ, &p);
		}
		else if (strcmp(command, "wait") == 0)
		{
			fscanf(stdin, "%d", &eventId);
			fscanf(stdin, "%d", &procId);

			// Creaza o stiva auxiliara
			TStack *aux = stack_new(sizeof(TProcess));

			// Muta procesele in stiva auxiliara pana cand procesul
			// cautat este gasit si mutat in stiva evenimentului
			TProcess *p;
			while (!queue_isEmpty(procQ))
			{
				p = queue_pop(procQ);

				if (p->id == procId)
				{
					stack_push(eventsStacks[eventId], p);
					free_process(p);
					break;
				}
				
				stack_push(aux, p);
				free_process(p);
			}

			// Muta procesele din stiva auxiliara inapoi in coada
			// de prioritati
			while (!stack_isEmpty(aux))
			{
				p = stack_pop(aux);
				queue_push(procQ, p);
				free_process(p);
			}

			// Distruge stiva auxiliara
			stack_destroy(&aux, free_process);
		}
		else if (strcmp(command, "event") == 0)
		{
			fscanf(stdin, "%d", &eventId);

			// Muta procesele din stiva evenimentului in coada
			// de prioritati
			TProcess *p;
			while (!stack_isEmpty(eventsStacks[eventId]))
			{
				p = stack_pop(eventsStacks[eventId]);
				queue_push(procQ, p);
				free_process(p);
			}
		}
		else if (strcmp(command, "end") == 0)
		{
			fscanf(stdin, "%d", &procId);

			// Creaza o stiva auxiliara
			TStack *aux = stack_new(sizeof(TProcess));

			// Muta procesele in stiva auxiliara pana cand procesul
			// cautat este gasit si sters
			TProcess *p;
			while (!queue_isEmpty(procQ))
			{
				p = queue_pop(procQ);

				if (p->id == procId)
				{
					free_process(p);
					break;
				}
				
				stack_push(aux, p);
				free_process(p);
			}

			// Muta procesele din stiva auxiliara inapoi in coada
			// de prioritati
			while (!stack_isEmpty(aux))
			{
				p = stack_pop(aux);
				queue_push(procQ, p);
				free_process(p);
			}

			// Distruge stiva auxiliara
			stack_destroy(&aux, free_process);
		}

		// Afiseaza iteratia
		printf("%d\n", iteration);

		// Afiseaza coada de prioritati
		if (!queue_isEmpty(procQ))
		{
			queue_print(procQ, print_process);
		}
		else
		{
			printf("\n");
		}

		// Afiseaza stivele
		for (i = 0; i < eventsNr; i++)
		{
			if (!stack_isEmpty(eventsStacks[i]))
			{
				printf("%d: ", i);
				stack_print(eventsStacks[i], print_process);
			}
		}

		printf("\n");
	}

	// Elibereaza memoria
	queue_destroy(&procQ, free_process);

	for (i = 0; i < eventsNr; i++)
	{
		stack_destroy(&eventsStacks[i], free_process);
	}
	free(eventsStacks);

	return 0;
}
Ejemplo n.º 16
0
/* In order to communicate with builtin_string, builtin_escape will return 2 to
 * indicate it did not push anything.
 */
int builtin_escape(interpreter* interp) {
  byte what, x0, x1;
  ++interp->ip;
  if (!is_ip_valid(interp)) {
    print_error("Escaped character expected");
    return 0;
  }

  switch (curr(interp)) {
  case '(':
  case ')':
  case '[':
  case ']':
  case '{':
  case '}':
  case '<':
  case '>': return 2;

  case 'a': what = '\a'; break;
  case 'b': what = '\b'; break;
  case 'e': what = '\033'; break;
  case 'f': what = '\f'; break;
  case 'n': what = '\n'; break;
  case 'r': what = '\r'; break;
  case 't': what = '\t'; break;
  case 'v': what = '\v'; break;
  case '"':
  case '\\':
  case '\'':
  case '$':
  case '%':
  case '`': what = curr(interp); break;
  case 'x': {
    /* Extract both digits if present. */
    ++interp->ip;
    if (is_ip_valid(interp)) {
      x0 = curr(interp);
      ++interp->ip;
      if (is_ip_valid(interp))
        x1 = curr(interp);
    }

    if (!is_ip_valid(interp)) {
      print_error("Two hexits expected after \\x");
      return 0;
    }

    /* Convert integer */
    if (x0 >= '0' && x0 <= '9')
      what = (x0 - '0') << 4;
    else if (x0 >= 'a' && x0 <= 'f')
      what = (x0 + 10 - 'a') << 4;
    else if (x0 >= 'A' && x0 <= 'F')
      what = (x0 + 10 - 'A') << 4;
    else {
      print_error("First \\x hexit is invalid");
      return 0;
    }
    if (x1 >= '0' && x1 <= '9')
      what |= (x1 - '0');
    else if (x1 >= 'a' && x1 <= 'f')
      what |= (x1 + 10 - 'a');
    else if (x1 >= 'A' && x1 <= 'F')
      what |= (x1 + 10 - 'A');
    else {
      print_error("Second \\x hexit is invalid");
      return 0;
    }
  } break;
  default:
    print_error("Invalid escape sequence");
    return 0;
  }

  /* Create and push the string. */
  stack_push(interp, create_string(&what, (&what)+1));
  return 1;
}
Ejemplo n.º 17
0
//逆ポーランドモードの関数
void rpn_calc(char* formula)
{
	printf("\tRPN Calc Exec : formula = \"%s\"\n",formula);

	double answer = 0;
	double ret = 0;
	int i;

	char tmp_buffer[BUFFER_LENGTH];
	int tmp_buffer_pointer = 0;
	string_clear(tmp_buffer,'\0',BUFFER_LENGTH);

	//実数が含まれるか確認
	for(i=0;formula[i]!='\0';i++)
	{
		if(formula[i]=='.')
		{
			double_flag = 1;
			printf("\tRPN Calc Exec : double mode is true\n");
			break;
		}
	}

	//計算ループ
	for(i=0;formula[i]!='\0';i++)
	{
		//数値の場合
		if((formula[i]>='0'&&formula[i]<='9')||formula[i]=='.')
		{
			tmp_buffer[tmp_buffer_pointer++] = formula[i];
		}
		//演算子の場合
		else if(formula[i]=='+'||formula[i]=='-'||formula[i]=='*'||formula[i]=='/')
		{
			if(tmp_buffer[0]!='\0')
			{
				if(double_flag==1)
					ret = my_atof(tmp_buffer);
				else
					ret = my_atoi(tmp_buffer);

				stack_push(ret);
				string_clear(tmp_buffer,'\0',BUFFER_LENGTH);
				tmp_buffer_pointer = 0;
			}
			stack_push(calc_exec(formula[i]));
		}
		//スペースまたはコンマの場合
		else if(formula[i]==' '||formula[i]==',')
		{
			if(tmp_buffer[0]!='\0')
			{
				if(double_flag==1)
					ret = my_atof(tmp_buffer);
				else
					ret = my_atoi(tmp_buffer);

				stack_push(ret);
				string_clear(tmp_buffer,'\0',BUFFER_LENGTH);
				tmp_buffer_pointer = 0;
			}
		}
	}

	//解答を取り出す
	answer = stack_pop();

	//エラーフラグのチェック
	if(error_flag==0)
	{
		//実数フラグによって表示方法を変更
		if(double_flag==0)
		{
			printf("\tAnswer : %d\n",(int)answer);
		}
		else
		{
			printf("\tAnswer : %lf\n",answer);
			double_flag = 0;
		}
	}
	else
	{
		//エラーが起こったときに答えを表示せずにエラー件数を表示して終了
		printf("\tError : Total Error -> %d\n",error_flag);
		error_flag = 0;
	}
}
Ejemplo n.º 18
0
void testStack() {
    // Create
    stack* my_stack = NULL;
    stack* dummy_stack = NULL;

    assert(stack_create(&my_stack) == 0); // Successfully create
    assert(stack_create(&dummy_stack) == 0); // Successfully create
    assert(stack_get_size(my_stack) == 0); // 0 size

    int a = 3;
    int b = 4;
    double c = 5.12;
    char d = 'c';
    char str[20] = "Hello World";

    // Successful pushes
    assert(stack_push(my_stack, &a, sizeof(a)) == 0);
    assert(stack_push(my_stack, &b, sizeof(b)) == 0);
    assert(stack_push(my_stack, &c, sizeof(c)) == 0);
    assert(stack_push(my_stack, &d, sizeof(d)) == 0);
    assert(stack_push(my_stack, str, strlen(str)) == 0);

    // Bad pushes:
    assert(stack_push(NULL, &a, sizeof(a)) != 0);
    assert(stack_push(my_stack, NULL, sizeof(a)) != 0);
    assert(stack_push(my_stack, &a, 0) != 0);

    assert(stack_get_size(my_stack) == 5); // 5 items

    int a2;
    int b2;
    double c2;
    char d2;
    char str2[20];

    // Bad pop:
    assert(stack_pop(NULL, &a) != 0);
    assert(stack_pop(dummy_stack, &a) != 0);
    assert(stack_pop(my_stack, NULL) != 0);

    // Successful pop:
    assert(stack_get_data_size(my_stack) <= 20);
    assert(stack_pop(my_stack, str2) == 0 && strcmp(str,str)==0);

    assert(stack_get_data_size(my_stack) == sizeof(d2));
    assert(stack_pop(my_stack, &d2) == 0 && d==d2);

    assert(stack_get_data_size(my_stack) == sizeof(c2));
    assert(stack_pop(my_stack, &c2) == 0 && c==c2);

    assert(stack_get_data_size(my_stack) == sizeof(b2));
    assert(stack_pop(my_stack, &b2) == 0 && b==b2);

    assert(stack_get_data_size(my_stack) == sizeof(a2));
    assert(stack_pop(my_stack, &a2) == 0 && a==a2);

    // Bad pop
    assert(stack_pop(my_stack, &a2) != 0);

    // Cleanup
    assert(stack_delete(my_stack) == 0); // Successfully create
    assert(stack_delete(dummy_stack) == 0); // Successfully create


    printf("Stack: Success\n");
}
Ejemplo n.º 19
0
static int
output(struct eval *eval, struct tok *tok)
{
	return stack_push(eval->stk, tok);
}
Ejemplo n.º 20
0
void instruction_execute_push(_pmachine m, _pinstruction ins)
{
    stack_push(&m->stack, (int)ins);
}
Ejemplo n.º 21
0
int enum_clients_events_cb(const struct event_base *base, const struct event *event, void *arg) {
	(void)base;
	enum_clients_events_cb_arg_struct *cb_arg = (enum_clients_events_cb_arg_struct *)arg;
	if (cb_arg->events_filter(event)) stack_push(&cb_arg->events_stack, event);
	return 0;
}
Ejemplo n.º 22
0
 inline void push_has_block(CallFrame* call_frame) {
   stack_push(RBOOL(CBOOL(call_frame->scope->block())));
 }
Ejemplo n.º 23
0
int dp_can_connect_str(str *domain, int rec_level) {
    struct rdata* head;
    struct rdata* l;
    struct naptr_rdata* naptr;
    struct naptr_rdata* next_naptr;
    int	   ret;
    str	   newdomain;
    char   uri[MAX_URI_SIZE];
    struct avp_stack stack;
    int    last_order = -1;
    int    failed = 0;
    int    found_anything = 0;

    str pattern, replacement, result;

    stack_reset(&stack);
    /* If we're in a recursive call, set the domain-replacement */
    if ( rec_level > 0 ) {
	stack_push(&stack, domain_replacement_name.s.s, domain->s);
	stack.succeeded = 0;
    }

    if (rec_level > MAX_DDDS_RECURSIONS) {
    	LM_ERR("too many indirect NAPTRs. Aborting at %.*s.\n", domain->len,
				ZSW(domain->s));
		return(DP_DDDS_RET_DNSERROR);
    }

    LM_INFO("looking up Domain itself: %.*s\n",domain->len, ZSW(domain->s));
    ret = check_rule(domain,"D2P+sip:dom", 11, &stack);

    if (ret == 1) {
	LM_INFO("found a match on domain itself\n");
	stack_to_avp(&stack);
	return(DP_DDDS_RET_POSITIVE);
    } else if (ret == 0) {
	LM_INFO("no match on domain itself.\n");
	stack_reset(&stack);
	/* If we're in a recursive call, set the domain-replacement */
	if ( rec_level > 0 ) {
	    stack_push(&stack, domain_replacement_name.s.s, (char *) domain->s);
	    stack.succeeded = 0;
	}
    } else {
	return(DP_DDDS_RET_DNSERROR);	/* actually: DB error */
    }

    LM_INFO("doing DDDS with %.*s\n",domain->len, ZSW(domain->s));
    head = get_record(domain->s, T_NAPTR, RES_ONLY_TYPE);
    if (head == 0) {
    	LM_NOTICE("no NAPTR record found for %.*s.\n", 
				domain->len, ZSW(domain->s));
    	return(DP_DDDS_RET_NOTFOUND);
    }

    LM_DBG("found the following NAPTRs: \n");
    for (l = head; l; l = l->next) {
	if (l->type != T_NAPTR) {
	    LM_DBG("found non-NAPTR record.\n");
	    continue; /*should never happen*/
	}
	naptr = (struct naptr_rdata*)l->rdata;
	if (naptr == 0) {
		LM_CRIT("null rdata\n");
		continue;
	}
	LM_DBG("order %u, pref %u, flen %u, flags '%.*s', slen %u, "
	    "services '%.*s', rlen %u, regexp '%.*s', repl '%s'\n", 
		naptr->order, naptr->pref,
	    naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
	    naptr->services_len,
	    (int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
	    (int)(naptr->regexp_len), ZSW(naptr->regexp),
	    ZSW(naptr->repl)
	    );
    }


    LM_DBG("sorting...\n");
    naptr_sort(&head);

    for (l = head; l; l = l->next) {

	if (l->type != T_NAPTR) continue; /*should never happen*/
	naptr = (struct naptr_rdata*)l->rdata;
	if (naptr == 0) {
		LM_CRIT("null rdata\n");
		continue;
	}

	LM_DBG("considering order %u, pref %u, flen %u, flags '%.*s', slen %u, "
	    "services '%.*s', rlen %u, regexp '%.*s', repl '%s'\n", 
		naptr->order, naptr->pref,
	    naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags),
	    naptr->services_len,
	    (int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
	    (int)(naptr->regexp_len), ZSW(naptr->regexp),
	    ZSW(naptr->repl)
	    );

	/*
	 * New order? then we check whether the had success during the last one.
	 * If yes, we can leave the loop.
	 */
	if (last_order != naptr->order) {
	    	last_order = naptr->order;
		failed = 0;

		if (stack_succeeded(&stack)) {
    		LM_INFO("we don't need to consider further orders "
						"(starting with %d).\n",last_order);
		    break;
		}
	} else if (failed) {
	    LM_INFO("order %d has already failed.\n",last_order);
	    continue;
	}


	/*
	 * NAPTRs we don't care about
	 */
	if (!IS_D2PNAPTR(naptr)) 
	    continue;

	/*
	 * once we've been here, don't return DP_DDDS_RET_NOTFOUND
	 */
	found_anything = 1;

	next_naptr = NULL;
	if (l->next && (l->next->type == T_NAPTR)) {
	     next_naptr = (struct naptr_rdata*)l->next->rdata;
	}

	/*
	 * Non-terminal?
	 */
	if ((naptr->services_len == 7) && !strncasecmp("D2P+SIP", naptr->services,7) && (naptr->flags_len == 0)){
	    LM_INFO("found non-terminal NAPTR\n");

	    /*
	     * This needs to be the only record with this order.
	     */
	    if (next_naptr && (next_naptr->order == naptr->order) && IS_D2PNAPTR(next_naptr)) {
	    	LM_ERR("non-terminal NAPTR needs to be the only one "
					"with this order %.*s.\n", domain->len, ZSW(domain->s));

		return(DP_DDDS_RET_DNSERROR);
	    }

	    newdomain.s = naptr->repl;
	    newdomain.len = strlen(naptr->repl);

	    ret = dp_can_connect_str(&newdomain, rec_level + 1);

	    if (ret == DP_DDDS_RET_POSITIVE)	/* succeeded, we're done. */
		return(ret);

	    if (ret == DP_DDDS_RET_NEGATIVE)	/* found rules, did not work */
		continue;			/* look for more rules */

	    if (ret == DP_DDDS_RET_DNSERROR)	/* errors during lookup */
		return(ret);			/* report them */

	    if (ret == DP_DDDS_RET_NOTFOUND)	/* no entries in linked domain? */
		return(ret);			/* ok, fine. go with that */

	    continue; /* not reached */
	}

	/*
	 * wrong kind of terminal
	 */
	if ((naptr->flags_len != 1) || (tolower(naptr->flags[0]) != 'u')) {
	    LM_ERR("terminal NAPTR needs flag = 'u' and not '%.*s'.\n",
					(int)naptr->flags_len, ZSW(naptr->flags));
		/*
		 * It's not that clear what we should do now: Ignore this records or regard it as failed.
		 * We go with "ignore" for now.
		 */
		continue;
	}

	if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
			       &pattern, &replacement) < 0) {
		LM_ERR("parsing of NAPTR regexp failed\n");
		continue;
	}
	result.s = &(uri[0]);
	result.len = MAX_URI_SIZE;

	/* Avoid making copies of pattern and replacement */
	pattern.s[pattern.len] = (char)0;
	replacement.s[replacement.len] = (char)0;
	if (reg_replace(pattern.s, replacement.s, domain->s,
			&result) < 0) {
		pattern.s[pattern.len] = '!';
		replacement.s[replacement.len] = '!';
		LM_ERR("regexp replace failed\n");
		continue;
	}
	LM_INFO("resulted in replacement: '%.*s'\n", result.len, ZSW(result.s));
	pattern.s[pattern.len] = '!';
	replacement.s[replacement.len] = '!';

	ret = check_rule(&result,naptr->services,naptr->services_len, &stack);

	if (ret == 1) {
	    LM_INFO("positive return\n");
	} else if (ret == 0) {
	    LM_INFO("check_rule failed.\n");
	    stack_reset(&stack);
	    /* If we're in a recursive call, set the domain-replacement */
	    if ( rec_level > 0 ) {
		stack_push(&stack, domain_replacement_name.s.s, (char *) domain->s);
		stack.succeeded = 0;
	    }
	    failed = 1;
	} else {
	    return(DP_DDDS_RET_DNSERROR);
    	}
    }

    if (stack_succeeded(&stack)) {
        LM_INFO("calling stack_to_avp.\n");
		stack_to_avp(&stack);
		return(DP_DDDS_RET_POSITIVE);
    }

    LM_INFO("returning %d.\n", 
	    (found_anything ? DP_DDDS_RET_NEGATIVE : DP_DDDS_RET_NOTFOUND));
    return(  found_anything ? DP_DDDS_RET_NEGATIVE : DP_DDDS_RET_NOTFOUND );
}
Ejemplo n.º 24
0
Archivo: mdv_un.c Proyecto: dv913/manna
int main(int argc, char *argv[]) {
  //sgenrand(time(NULL));
 int k, curr_pos, check;
int chunk; /* Repeat experiment in chunks. */
srand(SEED);

printf("# Info: $Header: /home/ma/p/pruess/.cvsroot/manna_range/dmitry_20151021/manna_stack_clean_edited.c,v 1.2 2015/10/21 11:37:00 pruess Exp $\n");
preamble(argc, argv);

PRINT_PARAM(SEED, "%lu");
PRINT_PARAM(LENGTH, "%lu");
PRINT_PARAM(DROP_LOCATION, "%lu");
PRINT_PARAM(total_malloced, "%lli");


printf("# Info: Expected avalanche size: <s>(x) = 1+(1/2) (<s>(x+1)+<s>(x-1)), BC <s>(0)=0, <s>(L+1)=0, solved by <s>(x)=(L+1-x)x/2.\n");
printf("# Info: Here L=LENGTH=%lu and x=DROP_LOCATION+1=%lu, so expect %g\n", LENGTH, DROP_LOCATION+1, ((double)(DROP_LOCATION+1))*((double)(LENGTH-DROP_LOCATION))/2.);


for (chunk=1; ((chunk<=NUM_CHUNKS) || (NUM_CHUNKS<0)); chunk++) {
MOMENTS_INIT(size);
for (drop = 0; drop < N_ROLLS; drop++) {  // big droppping cycle

size=0;

/*
printf("(%i.)", drop);
 for(k = 0; k<LENGTH; k++) {
    printf("\%i", lattice[k]); 
    }
 printf("\n");
*/

#if (1)
 if(check_cell(DROP_LOCATION) == 0) {
      lattice[DROP_LOCATION] = 1;
      }
 else {
      stack_push(DROP_LOCATION); 
      stack_push(DROP_LOCATION);
      lattice[DROP_LOCATION] = 0;
 }

/* If validated, optimse by turning stack operations into macros, 
 * optime random number drawing (rather than having doubles in the tree
 * have integers there and draw an integer to compare against),
 * optimise the shuffling of particles. 
 *
 * I have added MOMENT macros for size. */

  while(stack_used != 0) {
    curr_pos = stack_pop();


/* This code with the "check" looks clumsy. I suppose
 * you are "following through" topplings? I would think
 * there is no point doing this later. Anyway, we validate
 * this code and take it from there. */
    do {
      curr_pos = move_ball(curr_pos);

      if(curr_pos >= LENGTH || curr_pos < 0)  {
        check = 0 ;
        }
/* Why not just "else" instead of the "if"? */
      if(curr_pos < LENGTH && curr_pos >= 0) {
        check = check_cell(curr_pos);
        
        if (check == 1) {
          stack_push(curr_pos);
          }
      else {
        check = 0;
        }

    } 
  }while(check != 0);


  }/* end of while(stack_used != 0) look */
#endif

#if (0)
{
int npos;

#define PUSH(a) stack[stack_used++]=(a)
#define POP(a)  (a)=stack[--stack_used]

if (lattice[DROP_LOCATION]++==1) {
  PUSH(DROP_LOCATION);

    while(stack_used) {
      size++;
      POP(curr_pos);
      do {
	lattice[curr_pos]-=2;
	npos=curr_pos+ ( (rand()>RAND_MAX/2) ? 1 : -1);
	if ((npos>=0) && (npos<LENGTH)) {
	  if (lattice[npos]++==1) {PUSH(npos);}
	}
	if ((npos>=0) && (npos<LENGTH)) {
	  if (lattice[npos]++==1) {PUSH(npos);}
	}
      } while (lattice[curr_pos]>1);
    }
  }
}
#endif

//printf("size is %i\n", size);
MOMENTS(size,size);
} /* end of iterations loop */
MOMENTS_OUT(size);
} /* chunk */
postamble();
}
Ejemplo n.º 25
0
 inline void push_stack_local(CallFrame* call_frame, intptr_t which) {
   stack_push(stack_local(which));
 }
long double evaluate(string_t* expr) {
    int i, length;
    double result, a, b;
    char as_string[2] = "\0";
    char top, op, unused;
    stack values, ops;

    string_t formatted;
    init_string(&formatted, "");
    format_expression_string(expr, &formatted);

    stack_new(&values, sizeof(double));
    stack_new(&ops, sizeof(char));

    length = strlen(formatted.string);

    for(i = 0; i < length; i++) {
        /* Current token is a whitespace, skip it */
        if (formatted.string[i] == ' ')
            continue;

        /* Current token is a number, push it to stack for numbers */
        if((formatted.string[i] >= '0' && formatted.string[i] <= '9') || (formatted.string[i] == '.')) {
            string_t buf;
            init_string(&buf, "");

            /* There may be more than one digits in number */
            while((i < length) &&
                (((formatted.string[i] >= '0') && (formatted.string[i] <= '9')) || (formatted.string[i] == '.'))) {
                as_string[0] = formatted.string[i++];
                append(&buf, as_string);
            }

            result = atof(buf.string);
            stack_push(&values, &result);
        } else if(formatted.string[i] == '(') {
            /* Current token is an opening brace, push it to 'ops' */
            as_string[0] = formatted.string[i];
            stack_push(&ops, as_string);
        } else if(formatted.string[i] == ')') {
            /* Closing brace encountered, solve entire brace */
            while(TRUE) {
                stack_peek(&ops, &top);
                if(top == '(') break;

                stack_pop(&values, &a);
                stack_pop(&values, &b);

                stack_pop(&ops, &op);

                result = apply_op(op, a, b);
                stack_push(&values, &result);
            }

            stack_pop(&ops, &unused); /* pop ( */
        } else if(is_operator(formatted.string[i])) {
            /* While top of 'ops' has same or greater precedence to current
               token, which is an operator. Apply operator on top of 'ops'
               to top two elements in values stack */
            while(TRUE) {
                top = '(';
                if(!stack_empty(&ops))
                    stack_peek(&ops, &top);
                if(stack_empty(&ops) || !has_precedence(formatted.string[i], top)) break;

                stack_pop(&values, &a);
                stack_pop(&values, &b);
                stack_pop(&ops, &op);

                result = apply_op(op, a, b);
                
                /* !!!!!!!!!!!!!!!!!!!!
                    if(division_by_zero) {
                        return -255;
                    } */

                stack_push(&values, &result);
            }
        
            /* Push current token to 'ops'. */
            as_string[0] = formatted.string[i];
            stack_push(&ops, as_string);
        }
    }
    
    /* Entire expression has been parsed at this point, apply remaining
       ops to remaining values */
    while(!stack_empty(&ops)) {
        stack_pop(&values, &a);
        stack_pop(&values, &b);

        stack_pop(&ops, &op);
        result = apply_op(op, a, b);
        stack_push(&values, &result);
    }

    /* Top of 'values' contains result, return it */
    stack_pop(&values, &result);
    return result;
}
Ejemplo n.º 27
0
void append_call_stack(char type){
    obj * o = create_call_block(type, call_stack_top);
    stack_push(call_stack, o);
    call_stack_top = (call_block*)o->data;
}
Ejemplo n.º 28
0
static __inline void
push(struct value *v)
{

	stack_push(&bmachine.stack, v);
}
Ejemplo n.º 29
0
int
eval_instruction(struct vm_context **ctx)
{
  struct symbol *sym;
  struct object *value;
  struct compound_proc *template;

  switch (INS_AT((*ctx)->pc)->op) {
  case NONE:
    printf("Error: tried to execute a NONE op\n");
    exit(1);
    break;
  case PUSH:
    /* printf("PUSH instruction\n"); */
    stack_push((*ctx)->stk, INS_AT((*ctx)->pc)->arg);
    INC_REF(INS_AT((*ctx)->pc)->arg);
    ++(*ctx)->pc->offset;
    break;
  case POP:
    /* printf("POP instruction\n"); */
    value = stack_pop((*ctx)->stk);
    DEC_REF(value);
    ++(*ctx)->pc->offset;
    break;
  case LOOKUP:
    /* printf("LOOKUP instruction\n"); */
    assert(INS_AT((*ctx)->pc)->arg->type->code == SYMBOL_TYPE);
    sym = container_of(INS_AT((*ctx)->pc)->arg, struct symbol, obj);
    value = env_lookup((*ctx)->env, sym->value);
    if (! value) {
      char buf[1024];
      debug_loc_str(INS_AT((*ctx)->pc)->arg, buf, 1024);
      printf("%s: unbound name: %s\n", buf, sym->value);
      exit(1);
    }
    stack_push((*ctx)->stk, value);
    INC_REF(value);
    ++(*ctx)->pc->offset;
    break;
  case CALL:
  case TAILCALL:
    /* printf("CALL instruction @ %p\n", *pc); */
    eval_call(ctx);
    break;
  case RET:
    value = stack_pop((*ctx)->stk);
    struct object *orig_env = stack_pop((*ctx)->stk);
    assert(orig_env->type->code == ENVIRONMENT_TYPE);
    DEC_REF(orig_env);
    struct object *retaddr = stack_pop((*ctx)->stk);
    /* printf("RET instruction @ %p to %p\n", *pc, retaddr->cval); */
    stack_push((*ctx)->stk, value);
    DEC_REF(&(*ctx)->env->obj);
    (*ctx)->env = container_of(orig_env, struct environment, obj);
    if (retaddr == NULL) {
      (*ctx)->pc = NULL;
      return 1;
    }
    assert(retaddr->type->code == CODEPTR_TYPE);
    *(*ctx)->pc = *container_of(retaddr, struct codeptr, obj);
    /* XXX: */
    /* DEC_REF(retaddr); */
    break;
  case DEFINE:
    /* printf("DEFINE instruction\n"); */
    value = stack_pop((*ctx)->stk);
    assert(INS_AT((*ctx)->pc)->arg->type->code == SYMBOL_TYPE);
    sym = container_of(INS_AT((*ctx)->pc)->arg, struct symbol, obj);
    env_define((*ctx)->env, sym->value, value);
    DEC_REF(value);
    ++(*ctx)->pc->offset;
    break;
  case SET:
    value = stack_pop((*ctx)->stk);
    assert(INS_AT((*ctx)->pc)->arg->type->code == SYMBOL_TYPE);
    sym = container_of(INS_AT((*ctx)->pc)->arg, struct symbol, obj);
    env_set((*ctx)->env, sym->value, value);
    DEC_REF(value);
    ++(*ctx)->pc->offset;
    break;
  case LAMBDA:
    /* printf("LAMBDA instruction\n"); */
    value = INS_AT((*ctx)->pc)->arg;
    assert(INS_AT((*ctx)->pc)->arg->type->code == PROCEDURE_TYPE);
Ejemplo n.º 30
0
/* setup_stack_and_mttrs() determines the stack to use after
 * cache-as-ram is torn down as well as the MTRR settings to use. */
static void *setup_stack_and_mttrs(void)
{
	unsigned long top_of_stack;
	int num_mtrrs;
	uint32_t *slot;
	uint32_t mtrr_mask_upper;
	uint32_t top_of_ram;

	/* Top of stack needs to be aligned to a 4-byte boundary. */
	top_of_stack = choose_top_of_stack() & ~3;
	slot = (void *)top_of_stack;
	num_mtrrs = 0;

	/* The upper bits of the MTRR mask need to set according to the number
	 * of physical address bits. */
	mtrr_mask_upper = (1 << ((cpuid_eax(0x80000008) & 0xff) - 32)) - 1;

	/* The order for each MTRR is value then base with upper 32-bits of
	 * each value coming before the lower 32-bits. The reasoning for
	 * this ordering is to create a stack layout like the following:
	 *   +0: Number of MTRRs
	 *   +4: MTRR base 0 31:0
	 *   +8: MTRR base 0 63:32
	 *  +12: MTRR mask 0 31:0
	 *  +16: MTRR mask 0 63:32
	 *  +20: MTRR base 1 31:0
	 *  +24: MTRR base 1 63:32
	 *  +28: MTRR mask 1 31:0
	 *  +32: MTRR mask 1 63:32
	 */

	/* Cache the ROM as WP just below 4GiB. */
	slot = stack_push(slot, mtrr_mask_upper); /* upper mask */
	slot = stack_push(slot, ~(CONFIG_ROM_SIZE - 1) | MTRRphysMaskValid);
	slot = stack_push(slot, 0); /* upper base */
	slot = stack_push(slot, ~(CONFIG_ROM_SIZE - 1) | MTRR_TYPE_WRPROT);
	num_mtrrs++;

	/* Cache RAM as WB from 0 -> CONFIG_RAMTOP. */
	slot = stack_push(slot, mtrr_mask_upper); /* upper mask */
	slot = stack_push(slot, ~(CONFIG_RAMTOP - 1) | MTRRphysMaskValid);
	slot = stack_push(slot, 0); /* upper base */
	slot = stack_push(slot, 0 | MTRR_TYPE_WRBACK);
	num_mtrrs++;

	top_of_ram = (uint32_t)cbmem_top();
	/* Cache 8MiB below the top of ram. The top of ram under 4GiB is the
	 * start of the TSEG region. It is required to be 8MiB aligned. Set
	 * this area as cacheable so it can be used later for ramstage before
	 * setting up the entire RAM as cacheable. */
	slot = stack_push(slot, mtrr_mask_upper); /* upper mask */
	slot = stack_push(slot, ~((8 << 20) - 1) | MTRRphysMaskValid);
	slot = stack_push(slot, 0); /* upper base */
	slot = stack_push(slot, (top_of_ram - (8 << 20)) | MTRR_TYPE_WRBACK);
	num_mtrrs++;

	/* Cache 8MiB at the top of ram. Top of ram is where the TSEG
	 * region resides. However, it is not restricted to SMM mode until
	 * SMM has been relocated. By setting the region to cacheable it
	 * provides faster access when relocating the SMM handler as well
	 * as using the TSEG region for other purposes. */
	slot = stack_push(slot, mtrr_mask_upper); /* upper mask */
	slot = stack_push(slot, ~((8 << 20) - 1) | MTRRphysMaskValid);
	slot = stack_push(slot, 0); /* upper base */
	slot = stack_push(slot, top_of_ram | MTRR_TYPE_WRBACK);
	num_mtrrs++;

	/* Save the number of MTRRs to setup. Return the stack location
	 * pointing to the number of MTRRs. */
	slot = stack_push(slot, num_mtrrs);

	return slot;
}