int main(int argv, char** argc) { if (argv == 1) { std::cerr << "Must provide a command and arguments! Try parse, rewrite, compile, assemble\n"; return 0; } std::string flag = ""; std::string command = argc[1]; std::string input; std::string secondInput; if (std::string(argc[1]) == "-s") { flag = command.substr(1); command = argc[2]; input = ""; std::string line; while (std::getline(std::cin, line)) { input += line + "\n"; } secondInput = argv == 3 ? "" : argc[3]; } else { if (argv == 2) { std::cerr << "Not enough arguments for serpent cmdline\n"; throw(0); } input = argc[2]; secondInput = argv == 3 ? "" : argc[3]; } bool haveSec = secondInput.length() > 0; if (command == "parse" || command == "parse_serpent") { std::cout << printAST(parseSerpent(input), haveSec) << "\n"; } else if (command == "rewrite") { std::cout << printAST(rewrite(parseLLL(input, true)), haveSec) << "\n"; } else if (command == "compile_to_lll") { std::cout << printAST(compileToLLL(input), haveSec) << "\n"; } else if (command == "build_fragtree") { std::cout << printAST(buildFragmentTree(parseLLL(input, true))) << "\n"; } else if (command == "compile_lll") { std::cout << binToHex(compileLLL(parseLLL(input, true))) << "\n"; } else if (command == "dereference") { std::cout << printAST(dereference(parseLLL(input, true)), haveSec) <<"\n"; } else if (command == "pretty_assemble") { std::cout << printTokens(prettyAssemble(parseLLL(input, true))) <<"\n"; } else if (command == "pretty_compile_lll") { std::cout << printTokens(prettyCompileLLL(parseLLL(input, true))) << "\n"; } else if (command == "pretty_compile") { std::cout << printTokens(prettyCompile(input)) << "\n"; } else if (command == "assemble") { std::cout << assemble(parseLLL(input, true)) << "\n"; } else if (command == "serialize") { std::cout << binToHex(serialize(tokenize(input, Metadata(), false))) << "\n"; } else if (command == "flatten") { std::cout << printTokens(flatten(parseLLL(input, true))) << "\n"; } else if (command == "deserialize") { std::cout << printTokens(deserialize(hexToBin(input))) << "\n"; } else if (command == "compile") { std::cout << binToHex(compile(input)) << "\n"; } else if (command == "encode_datalist") { std::vector<Node> tokens = tokenize(input); std::vector<std::string> o; for (int i = 0; i < (int)tokens.size(); i++) { o.push_back(tokens[i].val); } std::cout << binToHex(encodeDatalist(o)) << "\n"; } else if (command == "decode_datalist") { std::vector<std::string> o = decodeDatalist(hexToBin(input)); std::vector<Node> tokens; for (int i = 0; i < (int)o.size(); i++) tokens.push_back(token(o[i])); std::cout << printTokens(tokens) << "\n"; } else if (command == "tokenize") { std::cout << printTokens(tokenize(input)); } else if (command == "biject") { if (argv == 3) std::cerr << "Not enough arguments for biject\n"; int pos = decimalToUnsigned(secondInput); std::vector<Node> n = prettyCompile(input); if (pos >= (int)n.size()) std::cerr << "Code position too high\n"; Metadata m = n[pos].metadata; std::cout << "Opcode: " << n[pos].val << ", file: " << m.file << ", line: " << m.ln << ", char: " << m.ch << "\n"; } }
void parseInstruction (git_uint32* pc, int * done) { git_uint32 pcStart = *pc; int modes [8]; git_uint32 opcode; static int ops = 0; ++ops; // Fetch the opcode. opcode = memRead8((*pc)++); // Check for multi-byte opcode. if (opcode & 0x80) { if (opcode & 0x40) { // Four-byte opcode. opcode &= 0x3F; opcode = (opcode << 8) | memRead8((*pc)++); opcode = (opcode << 8) | memRead8((*pc)++); opcode = (opcode << 8) | memRead8((*pc)++); } else { // Two-byte opcode. opcode &= 0x7F; opcode = (opcode << 8) | memRead8((*pc)++); } } if (gDebug) { emitCode (label_debug_step); emitData (pcStart); emitData (opcode); } // printf (" opcode=0x%x", opcode); // Now we have an opcode number, // parse the operands and emit code. switch (opcode) { case op_nop: emitCode (label_nop); break; // Arithmetic and logic case op_add: parseLLS (pc, label_add_discard); break; case op_sub: parseLLS (pc, label_sub_discard); break; case op_mul: parseLLS (pc, label_mul_discard); break; case op_div: parseLLS (pc, label_div_discard); break; case op_mod: parseLLS (pc, label_mod_discard); break; case op_bitand: parseLLS (pc, label_bitand_discard); break; case op_bitor: parseLLS (pc, label_bitor_discard); break; case op_bitxor: parseLLS (pc, label_bitxor_discard); break; case op_neg: parseLS (pc, label_neg_discard); break; case op_bitnot: parseLS (pc, label_bitnot_discard); break; case op_shiftl: parseLLS (pc, label_shiftl_discard); break; case op_ushiftr: parseLLS (pc, label_ushiftr_discard); break; case op_sshiftr: parseLLS (pc, label_sshiftr_discard); break; // Branches case op_jump: parseL_branch (pc, label_jump_var); *done = 1; break; case op_jz: parseLL_branch (pc, label_jz_var); break; case op_jnz: parseLL_branch (pc, label_jnz_var); break; case op_jeq: parseLLL_branch (pc, label_jeq_var); break; case op_jne: parseLLL_branch (pc, label_jne_var); break; case op_jlt: parseLLL_branch (pc, label_jlt_var); break; case op_jgt: parseLLL_branch (pc, label_jgt_var); break; case op_jle: parseLLL_branch (pc, label_jle_var); break; case op_jge: parseLLL_branch (pc, label_jge_var); break; case op_jltu: parseLLL_branch (pc, label_jltu_var); break; case op_jgtu: parseLLL_branch (pc, label_jgtu_var); break; case op_jleu: parseLLL_branch (pc, label_jleu_var); break; case op_jgeu: parseLLL_branch (pc, label_jgeu_var); break; case op_jumpabs: parseL (pc, label_jumpabs); *done = 1; break; // Moving data case op_copy: parseModeNibbles (pc, 2, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseStore (pc, reg_S1, modes [1], size32); break; case op_copys: parseModeNibbles (pc, 2, modes); parseLoad (pc, reg_L1, modes [0], size16, NULL); emitCode (label_copys_discard); parseStore (pc, reg_S1, modes [1], size16); break; case op_copyb: parseModeNibbles (pc, 2, modes); parseLoad (pc, reg_L1, modes [0], size8, NULL); emitCode (label_copyb_discard); parseStore (pc, reg_S1, modes [1], size8); break; case op_sexs: parseLS (pc, label_sexs_discard); break; case op_sexb: parseLS (pc, label_sexb_discard); break; // Array data case op_aload: parseLLS (pc, label_aload_discard); break; case op_aloads: parseLLS (pc, label_aloads_discard); break; case op_aloadb: parseLLS (pc, label_aloadb_discard); break; case op_aloadbit: parseLLS (pc, label_aloadbit_discard); break; case op_astore: parseLLL (pc, label_astore); break; case op_astores: parseLLL (pc, label_astores); break; case op_astoreb: parseLLL (pc, label_astoreb); break; case op_astorebit: parseLLL (pc, label_astorebit); break; // The stack case op_stkcount: parseS (pc, label_stkcount); break; case op_stkpeek: parseLS (pc, label_stkpeek); break; case op_stkswap: emitCode (label_stkswap); break; case op_stkcopy: parseL (pc, label_stkcopy); break; case op_stkroll: parseLL (pc, label_stkroll); break; // Functions case op_call: parseModeNibbles (pc, 3, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseLoad (pc, reg_L2, modes [1], size32, NULL); emitCode (label_args_stack); parseCallStub (pc, modes [2]); break; case op_callf: parseModeNibbles (pc, 2, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); emitCode (label_args_0); parseCallStub (pc, modes [1]); break; case op_callfi: parseModeNibbles (pc, 3, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseLoad (pc, reg_L2, modes [1], size32, NULL); emitCode (label_args_1); parseCallStub (pc, modes [2]); break; case op_callfii: parseModeNibbles (pc, 4, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseLoad (pc, reg_L2, modes [1], size32, NULL); parseLoad (pc, reg_L3, modes [2], size32, NULL); emitCode (label_args_2); parseCallStub (pc, modes [3]); break; case op_callfiii: parseModeNibbles (pc, 5, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseLoad (pc, reg_L2, modes [1], size32, NULL); parseLoad (pc, reg_L3, modes [2], size32, NULL); parseLoad (pc, reg_L4, modes [3], size32, NULL); emitCode (label_args_3); parseCallStub (pc, modes [4]); break; case op_return: parseL (pc, label_return); *done = 1; break; case op_tailcall: parseModeNibbles (pc, 2, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseLoad (pc, reg_L2, modes [1], size32, NULL); emitCode (label_args_stack); emitCode (label_tailcall); *done = 1; break; // Continuations case op_catch: parseCatch (pc); break; case op_throw: parseLL (pc, label_throw); *done = 1; break; case op_random: parseLS (pc, label_random); break; case op_setrandom: parseL (pc, label_setrandom); break; case op_getmemsize: parseS (pc, label_getmemsize); break; case op_setmemsize: parseLS (pc, label_setmemsize); break; case op_quit: emitCode (label_quit); *done = 1; break; case op_restart: emitCode (label_restart); *done = 1; break; case op_restore: parseLS (pc, label_restore); break; case op_restoreundo: parseS (pc, label_restoreundo); break; case op_protect: parseLL (pc, label_protect); break; case op_verify: parseS (pc, label_verify); break; case op_save: parseModeNibbles (pc, 2, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseSaveStub (pc, modes [1]); break; case op_saveundo: parseModeNibbles (pc, 1, modes); parseUndoStub (pc, modes [0]); break; case op_getiosys: parseSS (pc, label_getiosys); break; case op_setiosys: parseLL (pc, label_setiosys); break; case op_getstringtbl: parseS (pc, label_getstringtbl); break; case op_setstringtbl: parseL (pc, label_setstringtbl); break; case op_streamchar: parseL (pc, label_streamchar); emitData(*pc); break; case op_streamnum: parseL (pc, label_streamnum); emitData(*pc); break; case op_streamstr: parseL (pc, label_streamstr); emitData(*pc); break; case op_streamunichar: parseL (pc, label_streamunichar); emitData(*pc); break; case op_glk: parseLLS (pc, label_glk); break; case op_gestalt: parseLLS (pc, label_gestalt); break; case op_binarysearch: case op_linearsearch: parseModeNibbles (pc, 8, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseLoad (pc, reg_L2, modes [1], size32, NULL); parseLoad (pc, reg_L3, modes [2], size32, NULL); parseLoad (pc, reg_L4, modes [3], size32, NULL); parseLoad (pc, reg_L5, modes [4], size32, NULL); parseLoad (pc, reg_L6, modes [5], size32, NULL); parseLoad (pc, reg_L7, modes [6], size32, NULL); emitCode (opcode == op_linearsearch ? label_linearsearch : label_binarysearch); parseStore (pc, reg_S1, modes [7], size32); break; case op_linkedsearch: parseModeNibbles (pc, 7, modes); parseLoad (pc, reg_L1, modes [0], size32, NULL); parseLoad (pc, reg_L2, modes [1], size32, NULL); parseLoad (pc, reg_L3, modes [2], size32, NULL); parseLoad (pc, reg_L4, modes [3], size32, NULL); parseLoad (pc, reg_L5, modes [4], size32, NULL); parseLoad (pc, reg_L6, modes [5], size32, NULL); emitCode (label_linkedsearch); parseStore (pc, reg_S1, modes [6], size32); break; case op_debugtrap: parseL (pc, label_debugtrap); break; // Memory management case op_mzero: parseLL (pc, label_mzero); break; case op_mcopy: parseLLL (pc, label_mcopy); break; case op_malloc: parseLS (pc, label_malloc); break; case op_mfree: parseL (pc, label_mfree); break; // Function acceleration case op_accelfunc: parseLL (pc, label_accelfunc); break; case op_accelparam: parseLL (pc, label_accelparam); break; // Floating point case op_numtof: parseLS (pc, label_numtof); break; case op_ftonumz: parseLS (pc, label_ftonumz); break; case op_ftonumn: parseLS (pc, label_ftonumn); break; case op_ceil: parseLS (pc, label_ceil); break; case op_floor: parseLS (pc, label_floor); break; case op_sqrt: parseLS (pc, label_sqrt); break; case op_exp: parseLS (pc, label_exp); break; case op_log: parseLS (pc, label_log); break; case op_fadd: parseLLS (pc, label_fadd_discard); break; case op_fsub: parseLLS (pc, label_fsub_discard); break; case op_fmul: parseLLS (pc, label_fmul_discard); break; case op_fdiv: parseLLS (pc, label_fdiv_discard); break; case op_pow: parseLLS (pc, label_pow); break; case op_atan2: parseLLS (pc, label_atan2); break; case op_fmod: parseLLSS (pc, label_fmod); break; case op_sin: parseLS (pc, label_sin); break; case op_cos: parseLS (pc, label_cos); break; case op_tan: parseLS (pc, label_tan); break; case op_asin: parseLS (pc, label_asin); break; case op_acos: parseLS (pc, label_acos); break; case op_atan: parseLS (pc, label_atan); break; case op_jfeq: parseLLLL_branch (pc, label_jfeq_var); break; case op_jfne: parseLLLL_branch (pc, label_jfne_var); break; case op_jflt: parseLLL_branch (pc, label_jflt_var); break; case op_jfle: parseLLL_branch (pc, label_jfle_var); break; case op_jfgt: parseLLL_branch (pc, label_jfgt_var); break; case op_jfge: parseLLL_branch (pc, label_jfge_var); break; case op_jisnan: parseLL_branch (pc, label_jisnan_var); break; case op_jisinf: parseLL_branch (pc, label_jisinf_var); break; // Special Git opcodes case op_git_setcacheram: parseL (pc, label_git_setcacheram); break; case op_git_prunecache: parseLL (pc, label_git_prunecache); break; default: // Unknown opcode. abortCompilation(); break; } }