///Функция преобразует строку в постфиксную запись и работает с ней
char *vixod(char *input)
{
char *output;
output = new char[100];
output = shunting_yard(input, output);
return output;
}
int main(int argc, char *argv[]) {
FILE *fp = stdout;
if (argc > 1) {
fp = fopen(argv[1], "w+");
}
while(1) {
int fd[2], nbytes;
pid_t childpid;
char readbuffer[200];
pipe(fd);
if((childpid = fork()) == -1) {
perror("fork");
exit(1);
}
if(childpid == 0) {
/* Child process closes up input side of pipe */
close(fd[0]);
/* Send "string" through the output side of pipe */
char buff[200];
fgets (buff, 200, stdin);
write(fd[1], buff, (strlen(buff)+1));
exit(0);
}
else {
/* Parent process closes up output side of pipe */
close(fd[1]);
/* Read in a string from the pipe */
nbytes = read(fd[0], readbuffer, sizeof(readbuffer));
double result = 0.0;
Status status = shunting_yard(readbuffer, &result);
if (status != OK) {
show_error(status, fp);
} else {
fprintf(fp,"%.14g\n", result);
fflush(fp);
}
}
}
if (fp != stdout) {
fclose(fp);
}
return EXIT_SUCCESS;
}
int main() {
// functions: A() B(a) C(a, b), D(a, b, c) ...
// identifiers: 0 1 2 3 ... and a b c d e ...
// operators: = - + / * % !
const char *input = "a = D(f - b * c + d, !e, g)";
char output[128];
printf("input: %s\n", input);
if(shunting_yard(input, output)) {
printf("output: %s\n", output);
if(!execution_order(output))
printf("\nInvalid input\n");
}
return 0;
}
bool calc(const TCHAR *input, double *outval)
{
TCHAR output[IOBUFFERS], output2[IOBUFFERS];
calc_log ((_T("IN: '%s'\n"), input));
if (parse_values(input, output2)) {
if(shunting_yard(output2, output)) {
calc_log ((_T("RPN OUT: %s\n"), output));
if(!execution_order(output, outval)) {
calc_log ((_T("PARSE ERROR!\n")));
} else {
return true;
}
}
}
return false;
}
bool evalBoolExpr(char * expr) {
//printf("%s\n",expr);
//char * boolString[2] = {"FALSE", "TRUE"};
char output[2048] = {0};
char * op;
bool tmp;
char part1[1024], part2[1024];
if(!shunting_yard(expr, output))
return false; // oops can't convert to postfix form
while (strlen(output) > 1) {
op = &output[0];
while (!is_operator(*op) && *op != '\0')
op++;
if (*op == '\0') {
return false; // oops - zero operators found
}
else if (*op == '!') {
tmp = !(*(op-1) - 48);
*(op-1) = '\0';
}
else if(*op == '*') {
tmp = (*(op-1) - 48) && (*(op-2) - 48);
*(op-2) = '\0';
}
else if (*op == '+') {
tmp = (*(op-1) - 48) || (*(op-2) - 48);
*(op-2) = '\0';
}
memset(part1, 0, sizeof(part1));
memset(part2, 0, sizeof(part2));
strcpy(part1, output);
strcpy(part2, op+1);
memset(output, 0, sizeof(output));
strcat(output, part1);
strcat(output, ((tmp==false) ? "0" : "1"));
strcat(output, part2);
}
//return boolString[*output - 48];
return *output - 48;
}
Number parse(const std::string & infix_op, std::vector<std::string> & out_ops) {
std::stringstream stream(infix_op);
// start previous_op with a dummy value
// when previous_op is null it means that the last token was not an operation
std::vector<std::string> tokens = regex(infix_op);
std::transform (tokens.begin(), tokens.end(), tokens.begin(),
[](std::string s) {
std::transform( s.begin(), s.end(), s.begin(),
[](unsigned char c) {
return std::toupper(c);
});
return s;
});
if(!tokens.empty() && (tokens[0] == "FORMATO" || tokens[0] == "formato")) {
if(tokens.size() <= 1) {
throw std::string("invalid format syntax");
}
if(tokens[1] == "FIJO" || tokens[1] == "fijo") {
if(tokens.size() <= 2) throw std::string("invalid format syntax");
char * correct;
long fixed = std::strtol(tokens[2].c_str(), &correct, 10);
if(!correct) {
throw std::string("fijo size is not a number");
}
else {
Number::formato = Formato::FIJO;
//todo set fijo size
Number::fijo_size = fixed;
}
}
else if(tokens[1] == "REAL" || tokens[1] == "real") {
Number::formato = Formato::REAL;
}
else if(tokens[1] == "NC" || tokens[1] == "nc") {
Number::formato = Formato::NC;
}
else if(tokens[1] == "ESTANDAR" || tokens[1] == "estandar") {
Number::formato = Formato::ESTANDAR;
}
else {
throw std::string("invalid format syntax");
}
return Number("0","0");
}
if(tokens[0] == "SI" && tokens[1] == "[") {
if(tokens[tokens.size() -1] != ")") {
throw std::string("error en parentesis");
}
bool found_entonces, found_sino = false;
int i, j;
// acuerdate que cuando i salga de este loop va a estar incrementado en 1,
// igual en j AAGUAAANTA CREO QUE ES MENTIRA POR EL BREAK
for(i = 2; i < tokens.size() - 2; i++) {
if(tokens[i] == "]" && tokens[i+1] == "ENTONCES" && tokens[i+2] == "(") {
std::cout << "ENCONTRE ENTONCES!!" << '\n';
found_entonces = true;
break;
}
}
for(j = i; j < tokens.size()-2; j++) {
if(tokens[j] == ")" && tokens[j+1] == "SINO" && tokens[j+2] == "(") {
std::cout << "ENCONTRE SINO!!" << '\n';
found_sino = true;
break;
}
}
if(!found_entonces) {
throw std::string("syntax error");
}
else {
if(found_sino) {
std::vector<std::string> copy(&tokens[2], &tokens[i]);
Number b = shunting_yard(copy, out_ops, true);
if(!(b == Number("0","0"))) {
std::cout<<"TRUE" << '\n';
std::vector<std::string> copy(&tokens[i+3], &tokens[j]);
return shunting_yard (copy, out_ops, false);
}
else {
std::cout<<"FALSE" << '\n';
std::vector<std::string> copy(&tokens[j+3], &tokens[tokens.size()-1]);
return shunting_yard (copy, out_ops, false);
}
}
else {
std::vector<std::string> copy(&tokens[2], &tokens[i]);
Number b = shunting_yard(copy, out_ops, true);
if(!(b == Number("0","0"))) {
std::cout<<"TRUE" << '\n';
std::vector<std::string> copy(&tokens[i+3], &tokens[tokens.size()-1]);
return shunting_yard (copy, out_ops, false);
}
else {
std::cout<<"FALSE" << '\n';
}
}
}
return Number("0","0");
}
return shunting_yard(tokens, out_ops, false);
}
