Esempio n. 1
0
task4_6::solution::solution( const lines& calulator_lines )
{
	size_t i = 0;
	expressions exps;

	for(lines::const_iterator it = calulator_lines.begin(); it != calulator_lines.end(); it++, i++)
		rpn(*it, i, exps);

	make_values(exps);
}
Esempio n. 2
0
// requires: exp be a c string, with no
// spaces and only valid characters.
int rpn(char *exp, int size) {
  if (size == 1) {
    return 0;
  } else {
    if (check_constraints(exp, size)) {
      printf("%s\n", exp);
      printf("Constraints not met\n");
      return 1;
    }
    int delim_loc = get_delim(exp, size);
    char delim = exp[delim_loc];
    exp[delim_loc] = '\0';
    exp[size - 1] = '\0';
    char *left, *right;
    left = exp + 1;
    right = exp + delim_loc + 1;
    if (rpn(left, strlen(left)) ||
        rpn(right, strlen(right))) {
      return 1;
    }
    merge(exp, left, right, delim);
    return 0;
  }
}
Esempio n. 3
0
int main(int argc, char *argv[])
{
	char buf[BUFSIZ], *p;

	_printf("Ctrl-D to quit. > ");	
	while (fgets(buf, BUFSIZ, stdin)) {
		p = strchr(buf, '\n');
		if (p)
			*p = '\0';
		rpn(buf);
		_printf("Ctrl-D to quit. > ");	
	}
	_printf("\n");

	exit(EXIT_SUCCESS);
}
Esempio n. 4
0
void run_rpn_expression(NAMELIST_TEXT *nltext)
{
/*    expression = NULL; 
 */

    log_entry("run_rpn_expression");
   
    /* process the namelist text */
    set_namelist_processing_flags(STICKY_NAMELIST_DEFAULTS);
    set_print_namelist_flags(0);
    if (processNamelist(&rpn_expression, nltext)==NAMELIST_ERROR)
      bombElegant(NULL, NULL);
    if (echoNamelists) print_namelist(stdout, &rpn_expression);

    if (expression) {
        rpn(expression);
        if (rpn_check_error()) exitElegant(1);
        }
    log_exit("run_rpn_expression");
    }
Esempio n. 5
0
int main (int argc, char **argv) {
  if (argc == 1) {
    int exp_num;
    char exp[512];
    if (fgets(exp, sizeof(exp), stdin) &&
        sscanf(exp, "%d", &exp_num) == 1) {
      for (int i = 0; i < exp_num; i++) {
        if (fgets(exp, sizeof(exp), stdin)) {
          exp[strlen(exp) - 1] = '\0';
          rpn(exp, strlen(exp));
          printf("%s\n", exp);
        }
      }
    }
    return 0;
  } else {
    printf("Testing:\n");
    printf("Merge:\n");
    char buf[10];
    buf[0] = '0';
    buf[1] = '1';
    buf[2] = '2';
    buf[3] = '3';
    buf[4] = '4';
    buf[5] = '\0';
    buf[6] = '6';
    buf[7] = '7';
    buf[8] = '8';
    buf[9] = '\0';
    char *left, *right, delim = '+';
    left = buf + 1;
    right = buf + 5 + 1;
    merge(buf, left, right, delim);
    printf("%s\n", buf);
  }
}
Esempio n. 6
0
// @rpn:addDiv => [rpn ne retourne pas le bon resultat pour l entree: \"2 3 + 2 /\"]
void addDiv()
{
	char str[10] = "2 3 + 2 /";
	CU_ASSERT_EQUAL(rpn(str), 2.5);
}
Esempio n. 7
0
// @rpn:simpleDiv => [rpn ne retourne pas le bon resultat pour l entree: \"5 3 /\"]
void simpleDiv()
{
	char str[7] = "15 3 /";
	CU_ASSERT_EQUAL(rpn(str), 5);
}
Esempio n. 8
0
// @rpn:simpleMult => [rpn ne retourne pas le bon resultat pour l entree: \"5 3 *\"]
void simpleMult()
{
	char str[6] = "5 3 *";
	CU_ASSERT_EQUAL(rpn(str), 15);
}
Esempio n. 9
0
// @rpn:simpleDiff => [rpn ne retourne pas le bon resultat pour l entree: \"5 3 -\"]
void simpleDiff()
{
	char str[6] = "5 3 -";
	CU_ASSERT_EQUAL(rpn(str), 2);
}
Esempio n. 10
0
// @rpn:simpleAdd => [rpn ne retourne pas le bon resultat pour l entree: \"2 3 +\"]
void simpleAdd()
{
	char str[6] = "2 3 +";
	CU_ASSERT_EQUAL(rpn(str), 5);
}
Esempio n. 11
0
// @rpn:timesAdd => [rpn ne retourne pas le bon resultat pour l entree: \"2 3 * 2 +\"]
void timesAdd()
{
	char str[10] = "2 3 * 2 +";
	CU_ASSERT_EQUAL(rpn(str), 8);
}
Esempio n. 12
0
long assert_element_links(ELEMENT_LINKS *links, RUN *run, LINE_LIST *beamline, long flags)
{
    long i_link, i_elem, i_item, matrices_changed;
    long elem_type, data_type, param;
    double value;
    ELEMENT_LIST **targ, **sour;
    char *p_elem;
    short lengthChanged = 0;
    
    log_entry("assert_element_links");
    if (!links || links->n_links==0) {
        log_exit("assert_element_links");
        return(0);
        }

    if (!links->target_name || !links->item || !links->source_name || !links->equation ||
            !links->n_targets || !links->target_elem || !links->source_elem) {
        fputs("error: link structure has null pointers (assert_element_links)", stdout);
        abort();
        }

    matrices_changed = 0;
    for (i_link=0; i_link<links->n_links; i_link++) {
        if (!(flags&links->flags[i_link]))
            continue;
        targ = links->target_elem[i_link];
        sour = links->source_elem[i_link];
        elem_type = targ[0]->type;
        param     = links->target_param[i_link];
        data_type = entity_description[elem_type].parameter[param].type;
#if DEBUG
        fprintf(stdout, "asserting %ld links of %s.%s to %s\n", links->n_targets[i_link],
            links->target_name[i_link], links->item[i_link], links->source_name[i_link]);
        fflush(stdout);
        fprintf(stdout, "source type is %ld, with %ld parameters\n", sour[0]->type, 
                    entity_description[sour[0]->type].n_params);
        fflush(stdout);
#endif
        for (i_elem=0; i_elem<links->n_targets[i_link]; i_elem++) {
#if DEBUG
            fprintf(stdout, "  working on element %ld\n", i_elem);
            fflush(stdout);
#endif
            p_elem = sour[i_elem]->p_elem;
            for (i_item=0; i_item<entity_description[sour[0]->type].n_params; i_item++) {
  	        char s[1024];
		double value0;
                switch (entity_description[sour[0]->type].parameter[i_item].type) {
                    case IS_DOUBLE:
                        value = *((double*)(p_elem+entity_description[sour[0]->type].parameter[i_item].offset));
                        rpn_store(value, NULL, rpn_create_mem(entity_description[sour[0]->type].parameter[i_item].name, 0));
                        value0 = *((double*)(sour[i_elem]->p_elem0+entity_description[sour[0]->type].parameter[i_item].offset));
			sprintf(s, "%s0", entity_description[sour[0]->type].parameter[i_item].name);
                        rpn_store(value0, NULL, rpn_create_mem(s, 0));
                        break;
                    case IS_LONG:
                        value = *((long*)(p_elem+entity_description[sour[0]->type].parameter[i_item].offset));
                        rpn_store(value, NULL, rpn_create_mem(entity_description[sour[0]->type].parameter[i_item].name, 0));
                        value0 = *((long*)(sour[i_elem]->p_elem0+entity_description[sour[0]->type].parameter[i_item].offset));
			sprintf(s, "%s0", entity_description[sour[0]->type].parameter[i_item].name);
                        rpn_store(value0, NULL, rpn_create_mem(s, 0));
                        break;
                    default:
                        break;
                    }
#if DEBUG 
                fprintf(stdout, "    asserting value %e for %s\n", value, entity_description[sour[0]->type].parameter[i_item].name);
                fprintf(stdout, "    asserting value %e for %s0\n", value0, entity_description[sour[0]->type].parameter[i_item].name);
                fflush(stdout);
#endif
                }
            p_elem = targ[i_elem]->p_elem;

            rpn_clear();
            /* push original value onto stack */
            if (verbosity>1)
                fprintf(stdout, "prior value is %.15g for %s#%ld.%s at z=%.15gm\n",
                        links->baseline_value[i_link][i_elem], 
                        links->target_name[i_link], targ[i_elem]->occurence, links->item[i_link], 
                        targ[i_elem]->end_pos);
            push_num(links->baseline_value[i_link][i_elem]);
            value = rpn(links->equation[i_link]);
            if (rpn_check_error()) exitElegant(1);
            rpn_clear();
            if (value>links->maximum[i_link])
              value = links->maximum[i_link];
            if (value<links->minimum[i_link])
              value = links->minimum[i_link];
            if (verbosity>0)
                fprintf(stdout, "asserting value %.15g for %s#%ld.%s at z=%.15gm\n",
                    value, links->target_name[i_link], targ[i_elem]->occurence, links->item[i_link], targ[i_elem]->end_pos);
                fflush(stdout);
            if (entity_description[elem_type].flags&HAS_LENGTH && 
                entity_description[elem_type].parameter[param].offset==0)
              lengthChanged = 1;
            switch (data_type) {
                case IS_DOUBLE:
                    *((double*)(p_elem+entity_description[elem_type].parameter[param].offset)) = value;
                    break;
                case IS_LONG:
                    *((long*)(p_elem+entity_description[elem_type].parameter[param].offset)) = 
                      nearestInteger(value);
                    break;
                case IS_STRING:
                default:
                    bombElegant("unknown/invalid variable quantity (assert_element_links)", NULL);
                    exitElegant(1);
                }
            if (flags&LINK_ELEMENT_DEFINITION) 
                change_defined_parameter_values(&targ[i_elem]->name, &param, &targ[i_elem]->type, &value, 1);
            if ((entity_description[targ[0]->type].parameter[param].flags&PARAM_CHANGES_MATRIX) && targ[i_elem]->matrix) {
                free_matrices(targ[i_elem]->matrix);
                tfree(targ[i_elem]->matrix);
                targ[i_elem]->matrix = NULL;
                compute_matrix(targ[i_elem], run, NULL);
                matrices_changed++;
                }
            }
        }
#if DEBUG
    print_line(stdout, beamline);
#endif
    if (lengthChanged)
      compute_end_positions(beamline);
    log_exit("assert_element_links");
    return(matrices_changed);
    }
Esempio n. 13
0
 void ParseFormatNotationPostfix(const std::string& notation, FormatTokensVisitor& visitor)
 {
   RPNTranslation rpn(visitor);
   ParseFormatNotation(notation, rpn);
   rpn.Flush();
 }
Esempio n. 14
0
/*
 * in         - Source file to be interpreted
 * file_name  - Name of the source file, for debugging purposes
 * sym_table  - Global (master) symbol table
 */
void liten(FILE * in, char * file_name, slist * sym_table, token ** ret) {
    
  // *ret = NULL;

  slist * block_stack = slist_init();

  slist * local_table = slist_init();
  slist_push(sym_table, local_table);

  file_desc * desc = malloc(sizeof(file_desc));
  desc->file = in;
  desc->name = file_name;
  desc->line = 1;

  int tok;
  char * temp = malloc(sizeof(char)*MAX_STR);
  strcpy(temp, "\0");
  int type = -1;
  slist * tok_queue = slist_init();

  while (1) {
    if (in == stdin) {
      printf(":> ");
    } else if (tok == EOF) {
      break;
    }
    tok = getc(in);
    while (1) {
      if (tok == '\n' || tok == EOF) {
        desc->line++;
        tokenize(desc, &temp, &type, tok_queue);
        type = -1;
        // slist_print(tok_queue, slist_print_token);
        // TODO: Check line for syntax errors
        if (tok_queue->len == 0) break;
        if (block_stack->len == 0) {
          rpn(desc, tok_queue, sym_table, block_stack, ret);
        } else {
          char * temp_str = ((token *) slist_get(tok_queue, 0)->obj)->obj;
          block * temp = (block *) slist_get(block_stack, -1)->obj;
          if (strcmp("end", temp_str) == 0) {
	          rpn(desc, tok_queue, sym_table, block_stack, ret);
          } else if (strcmp("if", temp_str) == 0 ||
	          strcmp("while", temp_str) == 0) {
	          if (temp->value == 1)
	            rpn(desc, tok_queue, sym_table, block_stack, ret);
	          else {
	            block * temp1 = malloc(sizeof(block));
	            temp1->value = 0;
	            if (strcmp("if", temp_str) == 0) {
		            temp1->type = IF_B;
	            } else if (strcmp("while", temp_str) == 0) {
		            temp1->type = WHILE_B;
	            }
	            slist_push(block_stack, temp1);
	          }
          } else if (strcmp("elif", temp_str) == 0) {
	          if (temp->type != IF_B) lite_error(desc, "'elif' exists in 'if' block");
	          if (temp->value == 1) temp->value = 0;
	          else
	            rpn(desc, tok_queue, sym_table, block_stack, ret);
          } else if (strcmp("else", temp_str) == 0) {			
	          if (temp->type != IF_B) lite_error(desc, "'else' exists in 'if' block");
	          if (temp->value == 1) temp->value = 0;
	          else temp->value = 1;
          } else {
	          if (temp->value == 1)
	            rpn(desc, tok_queue, sym_table, block_stack, ret);
          }
        }
        
        tok_queue = slist_init();
        
        } else {
          token_parse(desc, tok, &temp, &type, tok_queue);
        }
         
        if (in == stdin && tok == '\n') break;
        tok = getc(in);
      }
    }

    return;
}
Esempio n. 15
0
// @rpn:divMinus => [rpn ne retourne pas le bon resultat pour l entree: \"6 3 / 1 -\"]
void divMinus()
{
	char str[10] = "6 3 / 1 -";
	CU_ASSERT_EQUAL(rpn(str), 1);
}
Esempio n. 16
0
// @rpn:minusTimes => [rpn ne retourne pas le bon resultat pour l entree: \"2 3 - 2 *\"]
void minusTimes()
{
	char str[10] = "2 3 - 2 *";
	CU_ASSERT_EQUAL(rpn(str), -2);
}
Esempio n. 17
0
int main(int argc, char **argv)
{
    double x_lo, x_hi, y_lo, y_hi, dx, dy, x, y;
    double **z_data, z_min, z_max, z_val;
    long ix, iy, nx, ny;
    long x_rpn_var, y_rpn_var;
    char *z_equation = NULL;
    char *rpn_defns_file;
    char *rpn_init_command;
    char *z_udf = "Z.UDF";
    char *input, *output, *label[4];
    long i_arg;
    SCANNED_ARG *s_arg;
    FILE *fp;
    unsigned long pipeFlags;
    char pfix[IFPF_BUF_SIZE], *ptr;
    char * rpn_defns;
#if defined(LINUX)
    struct stat sts;
#endif

    if (argc<2 || argc>(2+N_OPTIONS)) 
        bomb(NULL, USAGE);

    output = NULL;
    nx = ny = 0;
    rpn_defns_file = NULL;
    rpn_init_command = NULL;
    pipeFlags = 0;

    for (ix=0; ix<4; ix++)
        label[ix] = " ";
    scanargs(&s_arg, argc, argv);
    for (i_arg=1; i_arg<argc; i_arg++) {
        if (s_arg[i_arg].arg_type==OPTION) {
            delete_chars(s_arg[i_arg].list[0], "_");
            switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
                case SET_RPN_DEFNS_FILE:
                    if (s_arg[i_arg].n_items!=2 ||
                            !(rpn_defns_file=s_arg[i_arg].list[1]))
                        bomb("incorrect -rpndefnsfile syntax", NULL);
                    break;
                case SET_RPN_INIT_COMMAND:
		  /*
                    if (s_arg[i_arg].n_items!=2 ||
                            !(rpn_init_command = s_arg[i_arg].list[1]))
                        bomb("incorrect -rpncommand syntax", NULL);
		  */
		  if ((s_arg[i_arg].n_items<2) || (s_arg[i_arg].n_items>3))
		    SDDS_Bomb("incorrect -rpncommand syntax");
		  if (s_arg[i_arg].n_items==2) {
		    if (!strlen(rpn_init_command=s_arg[i_arg].list[1])) {
		      SDDS_Bomb("incorrect -rpncommand syntax");
		    }
		  } else if (s_arg[i_arg].n_items==3) {
		    if (strncmp(s_arg[i_arg].list[2], "algebraic", strlen(s_arg[i_arg].list[2]))==0) {
		      ptr = addOuterParentheses(s_arg[i_arg].list[1]);
		      if2pf(pfix, ptr, sizeof pfix);
		      free(ptr);
		      if (!SDDS_CopyString(&rpn_init_command, pfix)) {
			fprintf(stderr, "error: problem copying argument string\n");
			return(1);
		      }
		    } else {
		      SDDS_Bomb("incorrect -rpncommand syntax");
		    }
		  }
		  break;
                case SET_Z_EQUATION:
		  /*
                    if (s_arg[i_arg].n_items!=2 ||
			!(z_equation=s_arg[i_arg].list[1]))
                        bomb("incorrect -zequation syntax", NULL);
		  */
		  if ((s_arg[i_arg].n_items<2) || (s_arg[i_arg].n_items>3))
		    SDDS_Bomb("incorrect -zequation syntax");
		  if (s_arg[i_arg].n_items==2) {
		    if (!strlen(z_equation=s_arg[i_arg].list[1])) {
		      SDDS_Bomb("incorrect -zequation syntax");
		    }
		  } else if (s_arg[i_arg].n_items==3) {
		    if (strncmp(s_arg[i_arg].list[2], "algebraic", strlen(s_arg[i_arg].list[2]))==0) {
		      if2pf(pfix, s_arg[i_arg].list[1], sizeof pfix);
		      if (!SDDS_CopyString(&z_equation, pfix)) {
			fprintf(stderr, "error: problem copying argument string\n");
			return(1);
		      }
		    } else {
		      SDDS_Bomb("incorrect -zequation syntax");
		    }
		  }
		  break;
                case SET_X_RANGE:
                    if (s_arg[i_arg].n_items!=4 ||
                            1!=sscanf(s_arg[i_arg].list[1], "%le", &x_lo) ||
                            1!=sscanf(s_arg[i_arg].list[2], "%le", &x_hi) ||
                            x_lo>=x_hi || 
                            1!=sscanf(s_arg[i_arg].list[3], "%ld", &nx) ||
                            nx<=1) 
                        bomb("incorrect -xrange syntax", NULL);
                    break;
                case SET_Y_RANGE:
                    if (s_arg[i_arg].n_items!=4 ||
                            1!=sscanf(s_arg[i_arg].list[1], "%le", &y_lo) ||
                            1!=sscanf(s_arg[i_arg].list[2], "%le", &y_hi) ||
                            y_lo>=y_hi || 
                            1!=sscanf(s_arg[i_arg].list[3], "%ld", &ny) ||
                            ny<=1) 
                        bomb("incorrect -yrange syntax", NULL);
                    break;
                  case SET_PIPE:
                    if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags))
                        bomb("invalid -pipe syntax", NULL);
                    break;
                  default:
                    fprintf(stderr, "error: unknown switch: %s\n", s_arg[i_arg].list[0]);
                    bomb(NULL, NULL);
                    break;
                }
            }
        else {
            if (output==NULL) 
                output = s_arg[i_arg].list[0];
            else
                bomb("too many filenames (sddscongen)", NULL);
            }
        }

    pipeFlags |= DEFAULT_STDIN;
    input = NULL;
    processFilenames("sddscongen", &input, &output, pipeFlags, 0, NULL);

    if (nx==0)
        bomb("-xrange must be supplied", NULL);    
    if (ny==0)
        bomb("-yrange must be supplied", NULL);    
    
    if (z_equation==NULL)
        bomb("-zequation must be supplied", NULL);

    if(!rpn_defns_file) {
	rpn_defns_file=getenv("RPN_DEFNS");
	/*if failed, check where default setting exists for a linux system, G. Shen, Dec 31, 2009 */
	if(!rpn_defns_file) {
#if defined(LINUX)
	    if (!(stat(rpn_default, &sts) == -1 && errno == ENOENT)) { /* check whether default file exists */
		rpn_defns = rpn_default;
	    }
#endif
	}
    }
    rpn(rpn_defns_file);
    /* rpn(rpn_defns_file?rpn_defns_file:getenv("RPN_DEFNS")); */
    if (rpn_init_command)
        rpn(rpn_init_command);
    x_rpn_var = rpn_create_mem("x", 0);
    y_rpn_var = rpn_create_mem("y", 0);
    create_udf(z_udf, z_equation);

    z_data = (double**)array_2d(sizeof(double), 0, nx-1, 0, ny-1);
    dx = (x_hi-x_lo)/(nx-1);
    dy = (y_hi-y_lo)/(ny-1);
    z_min =  FLT_MAX;
    z_max = -FLT_MAX;
    
    for (ix=0,x=x_lo; ix<nx; ix++,x+=dx) {
        for (iy=0,y=y_lo; iy<ny; iy++,y+=dy) {
            rpn_store(x, NULL, x_rpn_var);
            rpn_store(y, NULL, y_rpn_var);
            if ((z_val = z_data[ix][iy] = rpn(z_udf))>z_max)
                z_max = z_val;
            if (z_val<z_min)
                z_min = z_val;
            rpn_clear();
            }
        }

    if (output)
        fp = fopen_e(output, "w", 0);
    else
        fp = stdout;
    fprintf(fp, "SDDS1\n&parameter name=Variable1Name, type=string, fixed_value=x &end\n");
    fprintf(fp, "&parameter name=Variable2Name, type=string, fixed_value=y &end\n");
    fprintf(fp, "&parameter name=xInterval, type=double, fixed_value=%e &end\n", dx);
    fprintf(fp, "&parameter name=xMinimum, type=double, fixed_value=%e &end\n", x_lo);
    fprintf(fp, "&parameter name=xDimension, type=long, fixed_value=%ld &end\n", nx);
    fprintf(fp, "&parameter name=yInterval, type=double, fixed_value=%e &end\n", dy);
    fprintf(fp, "&parameter name=yMinimum, type=double, fixed_value=%e &end\n", y_lo);
    fprintf(fp, "&parameter name=yDimension, type=long, fixed_value=%ld &end\n", ny);
    fprintf(fp, "&column name=z, type=double, description=\"%s\" &end\n", z_equation);
    fprintf(fp, "&data mode=ascii, no_row_counts=1 &end\n");
    for (ix=0; ix<nx; ix++)
         for (iy=0; iy<ny; iy++)
             fprintf(fp, "%e\n", z_data[ix][iy]);
    return(0);
}