// Parser for integers (eg, "123") or an integer range (eg, "123..456") bool get_range(const char **s, uint32 *pstart, uint32 *pend) { uint32 start, end; const char *tmp = *s; int ret = get_expression(&tmp, &start); if (!ret) return ret; if (tmp[0] != '.' || tmp[1] != '.') { // Only a single integer present. *s = tmp; *pend = *pstart = start; return ret; } // Looks like an integer range. tmp += 2; ret = get_expression(&tmp, &end); if (ret) { *s = tmp; if (start > end) { *pstart = end; *pend = start; } else { *pstart = start; *pend = end; } } return ret; }
void sysFncExec(TknKind kd) /* 내장함수실행 */ { double d; string s; switch (kd) { case Toint: code = nextCode(); stk.push((int)get_expression('(', ')')); /* 끝수 버림 */ break; case Input: nextCode(); nextCode(); code = nextCode(); /* input ( ) 건너뜀 */ getline(cin, s); /* 1행 읽기 */ stk.push(atof(s.c_str())); /* 숫자로 변환해서 저장 */ break; case Print: case Println: do { code = nextCode(); if (code.kind == String) { /* 문자열 출력 */ cout << code.text; code = nextCode(); } else { d = get_expression(); /* 함수 내에서 exit 가능성이 있다 */ if (!exit_Flg) cout << d; /* 수치 출력 */ } } while (code.kind == ','); /* , 라면 파라미터가 계속된다 */ if (kd == Println) cout << endl; /* println이면 줄바꿈 */ break; } }
auto do_binary_operator_complex( vector_expression<LExpr> const& lhs, vector_expression<RExpr> const& rhs, std::index_sequence<Is...>) noexcept { using vector_type = vector<typename Expr::value_type, Expr::size(), typename Expr::base_tag>; using binary_functor_type = typename Expr::functor_type; return vector_type{ binary_functor_type::get<Is>(get_expression(lhs), get_expression(rhs))... }; }
int main(int argc, char *argv[]) { int i, j, output; int test; char combinestr[100] = "("; if(argc == 1) { printf("Logical Expression 1 :\n"); get_expression(ipstr); truth_table(ipstr, fnvalues1, &numvar); strcat(combinestr, ipstr); strcat(combinestr, "="); printf("\nLogical Expression 2 :\n"); get_expression(ipstr); truth_table(ipstr, fnvalues2, &numvar); strcat(combinestr, ipstr); strcat(combinestr, ")"); truth_table(combinestr, fnvalues1, &numvar); test = test_for_tautology(fnvalues1, numvar); if(test == 1) printf("\nThe given functions are equivalent!\n"); else printf("\nThe given functions are NOT equivalent!\n"); } else if(argc != 3) { printf("Please enter exactly two logical expressions!"); return 0; } else { printf("Logical Expression 1 :\n"); strcpy(ipstr, argv[1]); truth_table(ipstr, fnvalues1, &numvar); strcat(combinestr, ipstr); strcat(combinestr, "="); printf("\nLogical Expression 2 :\n"); strcpy(ipstr, argv[2]); truth_table(ipstr, fnvalues2, &numvar); strcat(combinestr, ipstr); strcat(combinestr, ")"); truth_table(combinestr, fnvalues1, &numvar); test = test_for_tautology(fnvalues1, numvar); if(test == 1) printf("\nThe given functions are equivalent!\n"); else printf("\nThe given functions are NOT equivalent!\n"); } return 0; }
void bitsetVar::setVar(const char *s) { uint32 idx, val; if (!get_expression(&s, &idx) || !get_expression(&s, &val)) { ScriptError("Expected <index> <value>"); return; } if (idx > maxavail) { ScriptError("Index out of range (0..%d)", maxavail); return; } ASSIGNBIT(data, idx, val); }
static void LedSet(const char *cmd, const char *args) { uint32 id, value; if (!get_expression(&args, &id) || !get_expression(&args, &value)) { ScriptError("Expected <id> <value>"); return; } NLED_SETTINGS_INFO settings; settings.LedNum = id; settings.OffOnBlink = value; int ret = late_NLedSetDevice(NLED_SETTINGS_INFO_ID, &settings); if (!ret) Output("Return status of NLedSetDevice indicates failure"); }
size_t find_expression(const ExpressionTypePtr& expression) const { for(size_t i=0; i<num_expressions(); ++i) if(get_expression(i) == expression) return i; return num_expressions(); }
int main() { float num1, num2; char operation; char expression[51]; const int done = int('e'); fputs("enter an expresson to be evaluated.\nCurrently supports +-/*\n", stdout); fflush(stdout); while(1) { get_expression(expression, sizeof expression); printf("done = %i; expression = %s; int(expression) = %i\n", done, expression, int(expression)); switch(atoi(expression)) { case done: return(0); break; default: fputs("Invalid expression\n", stdout); } printf("%s\n", expression); /* scanf("%f%c%f", &num1, &operation, &num2); */ /* if(operation == '+') */ /* printf("%f\n", num1 + num2); */ /* if(operation == '/') */ /* printf("%f\n", num1 / num2); */ /* if(operation == '-') */ /* printf("%f\n", num1 - num2); */ /* if(operation == '*') */ /* printf("%f\n", num1 * num2); */ } return 0; }
static bool get_args (const char **s, const char *keyw, uint32 *args, uint count) { if (!count) return true; if (peek_char (s) != '(') { ScriptError("%s(%d args) expected", keyw, count); return false; } (*s)++; while (count--) { if (!get_expression (s, args, 0, count ? 0 : PAREN_EXPECT | PAREN_EAT)) { error: ScriptError("not enough arguments to function %s", keyw); return false; } if (!count) break; if (peek_char (s) != ',') goto error; (*s)++; args++; } return true; }
int main (int argc, char **argv) { if (argc < 2) { printf("Usage - `hexcalc {expression}`\n"); return 0; } FILE *fp; int status; char path[1024]; char *expression = get_expression(argc, argv); printf("evaling: %s\n", expression); char *exec_cmd = get_exec_cmd(expression); fp = popen(exec_cmd, "r"); if (fp == NULL) { printf("Failed to run command\n" ); return 1; } while (fgets(path, sizeof(path) - 1, fp) != NULL) { printf("result : %s", path); } free(expression); free(exec_cmd); pclose(fp); return 0; }
END_TEST START_TEST (test_expression) { int i; expression *e = get_expression("c1, symbol O+C"); ck_assert_ptr_ne(e,NULL); ck_assert_int_eq(e->type, E_SELECTION); ck_assert_ptr_ne(e->left, NULL); ck_assert_ptr_eq(e->right, NULL); ck_assert_str_eq(e->value, "c1"); ck_assert_int_eq(e->left->type,E_SYMBOL); ck_assert_ptr_ne(e->left->left,NULL); ck_assert_ptr_eq(e->left->right,NULL); ck_assert_int_eq(e->left->left->type,E_PLUS); ck_assert_int_eq(e->left->left->left->type,E_ID); ck_assert_int_eq(e->left->left->right->type,E_ID); ck_assert_str_eq(e->left->left->right->value,"C"); ck_assert_str_eq(e->left->left->left->value,"O"); for (i = E_SELECTION; i <= E_RANGE_OPEN_R; ++i) { ck_assert_ptr_ne(e_str(i), NULL); } ck_assert_ptr_eq(e_str(E_RANGE_OPEN_R+1), NULL); }
bool PossibleWord::operator==(const PossibleWord& rhs) const { return (is_valid() == rhs.is_valid() && get_expression() == rhs.get_expression() && get_tiles_to_use() == rhs.get_tiles_to_use() && get_score() == rhs.get_score()); }
bool intListVar::setVarItem(void *p, const char *s) { uint32 *d = (uint32*)p; if (! get_expression(&s, d)) { ScriptError("Expected <int>"); return false; } return true; }
END_TEST START_TEST (test_debug) /* this test just runs the debug output code to not get artificially low coverage */ { FILE *devnull = fopen("/dev/null", "w"); expression *e = get_expression("c1, symbol O+C"); print_expr(devnull, e, 0); }
static void cmd_memaccess(const char *tok, const char *args) { bool virt = toupper(tok[0]) == 'V'; uint32 addr, size; if (!get_expression(&args, &addr) || !get_expression(&args, &size)) { ScriptError("Expected <addr> <size>"); return; } alignMemAddr(&addr); if (virt) memDump((uint8 *)addr, size); else memPhysDump(addr, size); }
static void cmd_sleep(const char *cmd, const char *args) { uint32 msec; if (!get_expression(&args, &msec)) { ScriptError("Expected <milliseconds>"); return; } Sleep(msec); }
void syntaxChk() /* 구문 검사 */ { syntaxChk_mode = true; for (Pc=1; Pc<(int)intercode.size(); Pc++) { code = firstCode(Pc); switch (code.kind) { case Func: case Option: case Var: /* 검사 완료 */ break; case Else: case End: case Exit: code = nextCode(); chk_EofLine(); break; case If: case Elif: case While: code = nextCode(); (void)get_expression(0, EofLine); /* 식값 */ break; case For: code = nextCode(); (void)get_memAdrs(code); /* 제어 변수 주소 */ (void)get_expression('=', 0); /* 초깃값 */ (void)get_expression(To, 0); /* 최종값 */ if (code.kind == Step) (void)get_expression(Step,0); /* 증분값 */ chk_EofLine(); break; case Fcall: /* 대입 없는 함수 호출 */ fncCall_syntax(code.symNbr); chk_EofLine(); (void)stk.pop(); /* 반환 값 불필요 */ break; case Print: case Println: sysFncExec_syntax(code.kind); break; case Gvar: case Lvar: /* 대입문 */ (void)get_memAdrs(code); /* 좌변 주소 */ (void)get_expression('=', EofLine); /* 우변식 값 */ break; case Return: code = nextCode(); /* 반환 값 */ if (code.kind!='?' && code.kind!=EofLine) (void)get_expression(); if (code.kind == '?') (void)get_expression('?', 0); chk_EofLine(); break; case Break: code = nextCode(); if (code.kind == '?') (void)get_expression('?', 0); chk_EofLine(); break; case EofLine: break; default: err_exit("잘못된 기술입니다: ", kind_to_s(code.kind)); } } syntaxChk_mode = false; }
static void cmd_test(const char *cmd, const char *args) { uint32 val; if (!get_expression(&args, &val)) { ScriptError("expected <expr>"); return; } if (val) scrInterpret(args, ScriptLine); }
void rwfuncVar::setVar(const char *s) { uint32 val; uint32 args[50]; if (!get_args(&s, name, args, numargs)) return; if (!get_expression(&s, &val)) { ScriptError("Expected <value>"); return; } func(true, args, val); }
void sysFncExec_syntax(TknKind kd) /* 내장 함수 검사*/ { switch (kd) { case Toint: code = nextCode(); (void)get_expression('(', ')'); stk.push(1.0); break; case Input: code = nextCode(); code = chk_nextCode(code, '('); code = chk_nextCode(code, ')'); stk.push(1.0); /* 적당한 값 */ break; case Print: case Println: do { code = nextCode(); if (code.kind == String) code = nextCode(); /* 문자열 출력 확인 */ else (void)get_expression(); /* 값 출력 확인 */ } while (code.kind == ','); /* , 라면 파라미터가 계속된다 */ chk_EofLine(); break; } }
static void cmd_msgbox(const char *tok, const char *x) { wchar_t title[MAX_CMDLEN]; wchar_t msg[MAX_CMDLEN]; uint32 flags = 0; get_wtoken(&x, title, ARRAY_SIZE(title)); get_wtoken(&x, msg, ARRAY_SIZE(msg)); get_expression(&x, &flags); MsgBoxResult = MessageBox(0, msg, title, flags); }
static void cmd_runscript(const char *cmd, const char *args) { char vn[MAX_CMDLEN]; if (get_token(&args, vn, sizeof(vn))) { ScriptError("file name expected"); return; } uint32 ignore = 0; get_expression(&args, &ignore); scrExecute(vn, !ignore); }
static func_declaration *analyze_func(parse_source *source) { parse_token current = get_mandatory_token(source); func_declaration *func = new(func); func->parameters = ll_new(); if(current.type != WORD) { semantic_error("Function declaration must be in the form func <name>(<parameters>) <returntype> {<block>}", current.origin); } func->name = current.data; current = get_mandatory_token(source); if(current.data.data[0] != '(') { semantic_error("Function name must be followed by an open parenthesis", current.origin); } current = get_mandatory_token(source); while(current.data.data[0] != ')') { statement *name = new(name); name->type = NAME; name->children = ll_new(); if(current.type != WORD) { printf("%s\n", evaluate(current.data)); semantic_error("Parameter names must be a valid identifier", current.origin); } name->data = current.data; statement *param_type = parse_type_literal(source); ll_add_first(name->children, param_type); param_type->children = NULL; ll_add_last(func->parameters, name); current = get_mandatory_token(source); if(current.data.data[0] == ',') { current = get_mandatory_token(source); } } statement *returnType = parse_type_literal(source); func->type = returnType->data; free(returnType); current = peek_mandatory_token(source); if(current.data.data[0] != '{') { semantic_error("Function bodies must start with an open brace ('{')", current.origin); } int indent = 1; get_mandatory_token(source); func->root = new(func->root); func->root->type = ROOT; func->root->data = new_slice(""); func->root->children = ll_new(); while(indent > 0) { statement *state = get_expression(source, &indent); if(state != NULL) ll_add_last(func->root->children, state); } return func; }
static void powerMon(const char *cmd, const char *args) { uint32 seconds; if (!get_expression(&args, &seconds)) seconds = 0; uint32 start_time = GetTickCount(); uint32 cur_time = start_time; uint32 fin_time = cur_time + seconds * 1000; for (;;) { SYSTEM_POWER_STATUS_EX2 stat2; memset(&stat2, 0, sizeof(stat2)); int ret = late_GetSystemPowerStatusEx2(&stat2, sizeof(stat2), false); if (!ret) { Output(C_INFO "GetSystemPowerStatusEx2"); return; } Output("%06d: %5d %5d %% %5ld %5ld %5ld %5ld " "%5d %5d %5ld %5ld %5d %5d" " %5d %5d %5ld %5ld %5ld %5ld %5ld %5d", cur_time - start_time, // stat2.BatteryFlag, // stat2.BatteryLifePercent, // stat2.BatteryVoltage, // stat2.BatteryCurrent, // stat2.BatteryAverageCurrent, // stat2.BatteryTemperature, // stat2.ACLineStatus, // 0x00 stat2.Reserved1, // 0x00 stat2.BatteryLifeTime, // -1 stat2.BatteryFullLifeTime, // -1 stat2.Reserved2, // 0x00 stat2.BackupBatteryFlag, // 0x01 stat2.BackupBatteryLifePercent, // 255 stat2.Reserved3, // 0x00 stat2.BackupBatteryLifeTime, // -1 stat2.BackupBatteryFullLifeTime, // -1 stat2.BatteryAverageInterval, // 0 stat2.BatterymAHourConsumed, // 0 stat2.BackupBatteryVoltage, // 0 stat2.BatteryChemistry); // 5 cur_time = GetTickCount(); if (cur_time >= fin_time) break; Sleep(1000); } }
/* frdl hndl */ HRESULT CALLBACK frdl(PDEBUG_CLIENT4 Client, PCSTR args) { HRESULT ret=E_FAIL; set_client(Client); ULONG64 fh_val; if (!get_expression(args, &fh_val, &args)) goto finish; if (fh_val) file_rdln((FILE*)fh_val); ret=S_OK; finish: return ret; }
/* fwrt hndl input */ HRESULT CALLBACK fwrt(PDEBUG_CLIENT4 Client, PCSTR args) { HRESULT ret=E_FAIL; set_client(Client); ULONG64 fh_val; if (!get_expression(args, &fh_val, &args)) goto finish; for (; *args && isspace(*args); args++); if (fh_val && file_wrtstr((FILE*)fh_val, args)) ret=S_OK; finish: return ret; }
/* fcls hndl */ HRESULT CALLBACK fcls(PDEBUG_CLIENT4 Client, PCSTR args) { HRESULT ret=E_FAIL; set_client(Client); ULONG64 fh_val; if (!get_expression(args, &fh_val, NULL)) goto finish; if (!fh_val || fclose((FILE*)fh_val)) { err_dbgprintf("File closure error\n"); } else ret=S_OK; finish: return ret; }
bool PossibleWord::operator<(const PossibleWord& rhs) const { if (is_valid() < rhs.is_valid()) { return true; } else if (is_valid() == rhs.is_valid()) { if (get_expression() < rhs.get_expression()) { return true; } else if (get_expression() == rhs.get_expression()) { if (get_tiles_to_use() < rhs.get_tiles_to_use()) { return true; } else if (get_tiles_to_use() == rhs.get_tiles_to_use()) { return get_score() < rhs.get_score(); } else { return false; } } else { return false; } } else { return false; } }
std::unique_ptr<Expression> PostfixOperatorParser::parse(ElsaParser* parser, std::unique_ptr<Expression> left) { auto exp = std::make_unique<PostfixOperatorExpression>(); exp->set_expression(std::move(left)); exp->set_operator(parser->current_token()->get_type()); // Consume the operator token parser->consume(); exp->set_type(parser->type_checker().get_expression_type(exp->get_expression())); if(parser->current_token()->get_type() == TokenType::Semicolon) parser->consume(TokenType::Semicolon); return std::move(exp); }
void fncCall_syntax(int fncNbr) /* 함수 호출 검사 */ { int argCt = 0; code = nextCode(); code = chk_nextCode(code, '('); if (code.kind != ')') { /* 인수가 있다 */ for (;; code=nextCode()) { (void)get_expression(); ++argCt; /* 인수식 처리와 인수 개수 */ if (code.kind != ',') break; /* , 이면 인수가 계속된다 */ } } code = chk_nextCode(code, ')'); /* ) 일 것 */ if (argCt != Gtable[fncNbr].args) /* 인수 개수 검사 */ err_exit(Gtable[fncNbr].name, " 함수의 인수 개수가 잘못되었습니다"); stk.push(1.0); /* 적당한 반환 값 */ }