From da82ed52ac02497d343b898cca0bb2cf303f062d Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Thu, 8 May 2003 16:18:31 +0000 Subject: [PATCH] A large number of simple changes: * s/Method/Function * Kill some obsolete (external) functions that used to be to support tracing git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6041 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/ExecutionEngine/Interpreter/Execution.cpp | 37 +++---- .../Interpreter/ExecutionAnnotations.h | 19 ++-- .../Interpreter/ExternalFunctions.cpp | 102 ++---------------- .../Interpreter/Interpreter.cpp | 4 +- lib/ExecutionEngine/Interpreter/Interpreter.h | 26 ++--- lib/ExecutionEngine/Interpreter/Support.cpp | 23 ++-- lib/ExecutionEngine/Interpreter/UserInput.cpp | 62 ++++++----- 7 files changed, 95 insertions(+), 178 deletions(-) diff --git a/lib/ExecutionEngine/Interpreter/Execution.cpp b/lib/ExecutionEngine/Interpreter/Execution.cpp index 45fd5ffa7ae..852bca6b83b 100644 --- a/lib/ExecutionEngine/Interpreter/Execution.cpp +++ b/lib/ExecutionEngine/Interpreter/Execution.cpp @@ -157,8 +157,8 @@ static void SetValue(Value *V, GenericValue Val, ExecutionContext &SF) { void Interpreter::initializeExecutionEngine() { TheEE = this; - AnnotationManager::registerAnnotationFactory(MethodInfoAID, - &MethodInfo::Create); + AnnotationManager::registerAnnotationFactory(FunctionInfoAID, + &FunctionInfo::Create); initializeSignalHandlers(); } @@ -588,7 +588,7 @@ void Interpreter::executeRetInst(ReturnInst &I, ExecutionContext &SF) { } // Save previously executing meth - const Function *M = ECStack.back().CurMethod; + const Function *M = ECStack.back().CurFunction; // Pop the current stack frame... this invalidates SF ECStack.pop_back(); @@ -880,7 +880,7 @@ void Interpreter::executeCallInst(CallInst &I, ExecutionContext &SF) { // and treat it as a function pointer. GenericValue SRC = getOperandValue(I.getCalledValue(), SF); - callMethod((Function*)GVTOP(SRC), ArgVals); + callFunction((Function*)GVTOP(SRC), ArgVals); } static void executePHINode(PHINode &I, ExecutionContext &SF) { @@ -1014,7 +1014,7 @@ static void executeCastInst(CastInst &I, ExecutionContext &SF) { // Dispatch and Execution Code //===----------------------------------------------------------------------===// -MethodInfo::MethodInfo(Function *F) : Annotation(MethodInfoAID) { +FunctionInfo::FunctionInfo(Function *F) : Annotation(FunctionInfoAID) { // Assign slot numbers to the function arguments... for (Function::const_aiterator AI = F->abegin(), E = F->aend(); AI != E; ++AI) AI->addAnnotation(new SlotNumber(getValueSlot(AI))); @@ -1027,7 +1027,7 @@ MethodInfo::MethodInfo(Function *F) : Annotation(MethodInfoAID) { II->addAnnotation(new InstNumber(++InstNum, getValueSlot(II))); } -unsigned MethodInfo::getValueSlot(const Value *V) { +unsigned FunctionInfo::getValueSlot(const Value *V) { unsigned Plane = V->getType()->getUniqueID(); if (Plane >= NumPlaneElements.size()) NumPlaneElements.resize(Plane+1, 0); @@ -1036,15 +1036,15 @@ unsigned MethodInfo::getValueSlot(const Value *V) { //===----------------------------------------------------------------------===// -// callMethod - Execute the specified function... +// callFunction - Execute the specified function... // -void Interpreter::callMethod(Function *F, - const std::vector &ArgVals) { +void Interpreter::callFunction(Function *F, + const std::vector &ArgVals) { assert((ECStack.empty() || ECStack.back().Caller == 0 || ECStack.back().Caller->getNumOperands()-1 == ArgVals.size()) && "Incorrect number of arguments passed into function call!"); if (F->isExternal()) { - GenericValue Result = callExternalMethod(F, ArgVals); + GenericValue Result = callExternalFunction(F, ArgVals); const Type *RetTy = F->getReturnType(); // Copy the result back into the result variable if we are not returning @@ -1074,23 +1074,24 @@ void Interpreter::callMethod(Function *F, // the function. Also calculate the number of values for each type slot // active. // - MethodInfo *MethInfo = (MethodInfo*)F->getOrCreateAnnotation(MethodInfoAID); + FunctionInfo *FuncInfo = + (FunctionInfo*)F->getOrCreateAnnotation(FunctionInfoAID); ECStack.push_back(ExecutionContext()); // Make a new stack frame... ExecutionContext &StackFrame = ECStack.back(); // Fill it in... - StackFrame.CurMethod = F; + StackFrame.CurFunction = F; StackFrame.CurBB = F->begin(); StackFrame.CurInst = StackFrame.CurBB->begin(); - StackFrame.MethInfo = MethInfo; + StackFrame.FuncInfo = FuncInfo; // Initialize the values to nothing... - StackFrame.Values.resize(MethInfo->NumPlaneElements.size()); - for (unsigned i = 0; i < MethInfo->NumPlaneElements.size(); ++i) { - StackFrame.Values[i].resize(MethInfo->NumPlaneElements[i]); + StackFrame.Values.resize(FuncInfo->NumPlaneElements.size()); + for (unsigned i = 0; i < FuncInfo->NumPlaneElements.size(); ++i) { + StackFrame.Values[i].resize(FuncInfo->NumPlaneElements[i]); // Taint the initial values of stuff memset(&StackFrame.Values[i][0], 42, - MethInfo->NumPlaneElements[i]*sizeof(GenericValue)); + FuncInfo->NumPlaneElements[i]*sizeof(GenericValue)); } StackFrame.PrevBB = 0; // No previous BB for PHI nodes... @@ -1345,7 +1346,7 @@ void Interpreter::infoValue(const std::string &Name) { // void Interpreter::printStackFrame(int FrameNo) { if (FrameNo == -1) FrameNo = CurFrame; - Function *F = ECStack[FrameNo].CurMethod; + Function *F = ECStack[FrameNo].CurFunction; const Type *RetTy = F->getReturnType(); CW << ((FrameNo == CurFrame) ? '>' : '-') << "#" << FrameNo << ". " diff --git a/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h b/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h index 1a5c7fee980..25b31cd8b40 100644 --- a/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h +++ b/lib/ExecutionEngine/Interpreter/ExecutionAnnotations.h @@ -8,7 +8,7 @@ #define LLI_EXECUTION_ANNOTATIONS_H //===----------------------------------------------------------------------===// -// Support for MethodInfo annotations +// Support for FunctionInfo annotations //===----------------------------------------------------------------------===// // This annotation (attached only to Function objects) is used to cache useful @@ -18,20 +18,19 @@ // This annotation object is created on demand, and attaches other annotation // objects to the instructions in the function when it's created. // -static AnnotationID MethodInfoAID( +static AnnotationID FunctionInfoAID( AnnotationManager::getID("Interpreter::FunctionInfo")); -struct MethodInfo : public Annotation { - MethodInfo(Function *F); +struct FunctionInfo : public Annotation { + FunctionInfo(Function *F); std::vector NumPlaneElements; - - // Create - Factory function to allow MethodInfo annotations to be + // Create - Factory function to allow FunctionInfo annotations to be // created on demand. // static Annotation *Create(AnnotationID AID, const Annotable *O, void *) { - assert(AID == MethodInfoAID); - return new MethodInfo(cast((Value*)O)); // Simply invoke the ctor + assert(AID == FunctionInfoAID); + return new FunctionInfo(cast((Value*)O)); } private: @@ -47,7 +46,7 @@ private: // hold the the slot number for the value in its type plane. // // Entities have this annotation attached to them when the containing -// function has it's MethodInfo created (by the MethodInfo ctor). +// function has it's FunctionInfo created (by the FunctionInfo ctor). // static AnnotationID SlotNumberAID( AnnotationManager::getID("Interpreter::SlotNumber")); @@ -72,7 +71,7 @@ struct SlotNumber : public Annotation { // calculating which value slot to store the result of the instruction in. // // Instructions have this annotation attached to them when the containing -// function has it's MethodInfo created (by the MethodInfo ctor). +// function has it's FunctionInfo created (by the FunctionInfo ctor). // struct InstNumber : public SlotNumber { unsigned InstNum; // Ranges from 1-> diff --git a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp index aa900ea3b43..ef81c128b12 100644 --- a/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp +++ b/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp @@ -22,7 +22,6 @@ #include #include using std::vector; -using std::cout; typedef GenericValue (*ExFunc)(FunctionType *, const vector &); static std::map Functions; @@ -78,7 +77,7 @@ static ExFunc lookupFunction(const Function *M) { ExtName += getTypeID(Ty); ExtName += "_" + M->getName(); - //cout << "Tried: '" << ExtName << "'\n"; + //std::cout << "Tried: '" << ExtName << "'\n"; ExFunc FnPtr = FuncNames[ExtName]; if (FnPtr == 0) FnPtr = (ExFunc)dlsym(RTLD_DEFAULT, ExtName.c_str()); @@ -91,7 +90,7 @@ static ExFunc lookupFunction(const Function *M) { return FnPtr; } -GenericValue Interpreter::callExternalMethod(Function *M, +GenericValue Interpreter::callExternalFunction(Function *M, const vector &ArgVals) { TheInterpreter = this; @@ -100,8 +99,8 @@ GenericValue Interpreter::callExternalMethod(Function *M, std::map::iterator FI = Functions.find(M); ExFunc Fn = (FI == Functions.end()) ? lookupFunction(M) : FI->second; if (Fn == 0) { - cout << "Tried to execute an unknown external function: " - << M->getType()->getDescription() << " " << M->getName() << "\n"; + std::cout << "Tried to execute an unknown external function: " + << M->getType()->getDescription() << " " << M->getName() << "\n"; return GenericValue(); } @@ -117,85 +116,21 @@ GenericValue Interpreter::callExternalMethod(Function *M, // extern "C" { // Don't add C++ manglings to llvm mangling :) -// Implement void printstr([ubyte {x N}] *) -GenericValue lle_VP_printstr(FunctionType *M, - const vector &ArgVal){ - assert(ArgVal.size() == 1 && "printstr only takes one argument!"); - cout << (char*)GVTOP(ArgVal[0]); - return GenericValue(); -} - -// Implement 'void print(X)' for every type... -GenericValue lle_X_print(FunctionType *M, const vector &ArgVals) { - assert(ArgVals.size() == 1 && "generic print only takes one argument!"); - - Interpreter::print(M->getParamTypes()[0], ArgVals[0]); - return GenericValue(); -} - -// Implement 'void printVal(X)' for every type... -GenericValue lle_X_printVal(FunctionType *M, - const vector &ArgVal) { - assert(ArgVal.size() == 1 && "generic print only takes one argument!"); - - // Specialize print([ubyte {x N} ] *) and print(sbyte *) - if (const PointerType *PTy = - dyn_cast(M->getParamTypes()[0].get())) - if (PTy->getElementType() == Type::SByteTy || - isa(PTy->getElementType())) { - return lle_VP_printstr(M, ArgVal); - } - - Interpreter::printValue(M->getParamTypes()[0], ArgVal[0]); - return GenericValue(); -} - -// Implement 'void printString(X)' -// Argument must be [ubyte {x N} ] * or sbyte * -GenericValue lle_X_printString(FunctionType *M, - const vector &ArgVal) { - assert(ArgVal.size() == 1 && "generic print only takes one argument!"); - return lle_VP_printstr(M, ArgVal); -} - -// Implement 'void print(X)' for each primitive type or pointer type -#define PRINT_TYPE_FUNC(TYPENAME,TYPEID) \ - GenericValue lle_X_print##TYPENAME(FunctionType *M,\ - const vector &ArgVal) {\ - assert(ArgVal.size() == 1 && "generic print only takes one argument!");\ - assert(M->getParamTypes()[0].get()->getPrimitiveID() == Type::TYPEID);\ - Interpreter::printValue(M->getParamTypes()[0], ArgVal[0]);\ - return GenericValue();\ - } - -PRINT_TYPE_FUNC(SByte, SByteTyID) -PRINT_TYPE_FUNC(UByte, UByteTyID) -PRINT_TYPE_FUNC(Short, ShortTyID) -PRINT_TYPE_FUNC(UShort, UShortTyID) -PRINT_TYPE_FUNC(Int, IntTyID) -PRINT_TYPE_FUNC(UInt, UIntTyID) -PRINT_TYPE_FUNC(Long, LongTyID) -PRINT_TYPE_FUNC(ULong, ULongTyID) -PRINT_TYPE_FUNC(Float, FloatTyID) -PRINT_TYPE_FUNC(Double, DoubleTyID) -PRINT_TYPE_FUNC(Pointer, PointerTyID) - - // void putchar(sbyte) GenericValue lle_Vb_putchar(FunctionType *M, const vector &Args) { - cout << Args[0].SByteVal; + std::cout << Args[0].SByteVal; return GenericValue(); } // int putchar(int) GenericValue lle_ii_putchar(FunctionType *M, const vector &Args) { - cout << ((char)Args[0].IntVal) << std::flush; + std::cout << ((char)Args[0].IntVal) << std::flush; return Args[0]; } // void putchar(ubyte) GenericValue lle_VB_putchar(FunctionType *M, const vector &Args) { - cout << Args[0].SByteVal << std::flush; + std::cout << Args[0].SByteVal << std::flush; return Args[0]; } @@ -395,7 +330,7 @@ GenericValue lle_X_sprintf(FunctionType *M, const vector &Args) { sprintf(Buffer, FmtBuf, (void*)GVTOP(Args[ArgNo++])); break; case 's': sprintf(Buffer, FmtBuf, (char*)GVTOP(Args[ArgNo++])); break; - default: cout << ""; + default: std::cout << ""; ArgNo++; break; } strcpy(OutputBuffer, Buffer); @@ -413,7 +348,7 @@ GenericValue lle_X_printf(FunctionType *M, const vector &Args) { NewArgs.push_back(PTOGV(Buffer)); NewArgs.insert(NewArgs.end(), Args.begin(), Args.end()); GenericValue GV = lle_X_sprintf(M, NewArgs); - cout << Buffer; + std::cout << Buffer; return GV; } @@ -763,22 +698,7 @@ GenericValue lle_X_fprintf(FunctionType *M, const vector &Args) { } // End extern "C" -void Interpreter::initializeExternalMethods() { - FuncNames["lle_VP_printstr"] = lle_VP_printstr; - FuncNames["lle_X_print"] = lle_X_print; - FuncNames["lle_X_printVal"] = lle_X_printVal; - FuncNames["lle_X_printString"] = lle_X_printString; - FuncNames["lle_X_printUByte"] = lle_X_printUByte; - FuncNames["lle_X_printSByte"] = lle_X_printSByte; - FuncNames["lle_X_printUShort"] = lle_X_printUShort; - FuncNames["lle_X_printShort"] = lle_X_printShort; - FuncNames["lle_X_printInt"] = lle_X_printInt; - FuncNames["lle_X_printUInt"] = lle_X_printUInt; - FuncNames["lle_X_printLong"] = lle_X_printLong; - FuncNames["lle_X_printULong"] = lle_X_printULong; - FuncNames["lle_X_printFloat"] = lle_X_printFloat; - FuncNames["lle_X_printDouble"] = lle_X_printDouble; - FuncNames["lle_X_printPointer"] = lle_X_printPointer; +void Interpreter::initializeExternalFunctions() { FuncNames["lle_Vb_putchar"] = lle_Vb_putchar; FuncNames["lle_ii_putchar"] = lle_ii_putchar; FuncNames["lle_VB_putchar"] = lle_VB_putchar; @@ -810,7 +730,7 @@ void Interpreter::initializeExternalMethods() { FuncNames["lle_X_strcat"] = lle_X_strcat; FuncNames["lle_X_strcpy"] = lle_X_strcpy; FuncNames["lle_X_strlen"] = lle_X_strlen; - FuncNames["lle_X___strdup"] = lle_X___strdup; + FuncNames["lle_X___strdup"] = lle_X___strdup; FuncNames["lle_X_memset"] = lle_X_memset; FuncNames["lle_X_memcpy"] = lle_X_memcpy; diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.cpp b/lib/ExecutionEngine/Interpreter/Interpreter.cpp index 5c116757ca4..1c41841b812 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.cpp +++ b/lib/ExecutionEngine/Interpreter/Interpreter.cpp @@ -32,7 +32,7 @@ Interpreter::Interpreter(Module *M, unsigned Config, setTargetData(TD); // Initialize the "backend" initializeExecutionEngine(); - initializeExternalMethods(); + initializeExternalFunctions(); CW.setModule(M); // Update Writer } @@ -42,7 +42,7 @@ int Interpreter::run(const std::string &MainFunction, const std::vector &Args) { // Start interpreter into the main function... // - if (!callMainMethod(MainFunction, Args) && !Debug) { + if (!callMainFunction(MainFunction, Args) && !Debug) { // If not in debug mode and if the call succeeded, run the code now... run(); } diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h index 4dacf22c15f..0b01f8df58e 100644 --- a/lib/ExecutionEngine/Interpreter/Interpreter.h +++ b/lib/ExecutionEngine/Interpreter/Interpreter.h @@ -19,7 +19,7 @@ extern CachedWriter CW; // Object to accelerate printing of LLVM -struct MethodInfo; // Defined in ExecutionAnnotations.h +struct FunctionInfo; // Defined in ExecutionAnnotations.h class CallInst; class ReturnInst; class BranchInst; @@ -63,10 +63,10 @@ typedef std::vector ValuePlaneTy; // executing. // struct ExecutionContext { - Function *CurMethod; // The currently executing function + Function *CurFunction;// The currently executing function BasicBlock *CurBB; // The currently executing BB BasicBlock::iterator CurInst; // The next instruction to execute - MethodInfo *MethInfo; // The MethInfo annotation for the function + FunctionInfo *FuncInfo; // The FuncInfo annotation for the function std::vector Values;// ValuePlanes for each type std::vector VarArgs; // Values passed through an ellipsis @@ -111,21 +111,21 @@ public: void handleUserInput(); // User Interation Methods... - bool callMethod(const std::string &Name); // return true on failure + bool callFunction(const std::string &Name); // return true on failure void setBreakpoint(const std::string &Name); void infoValue(const std::string &Name); void print(const std::string &Name); static void print(const Type *Ty, GenericValue V); static void printValue(const Type *Ty, GenericValue V); - bool callMainMethod(const std::string &MainName, - const std::vector &InputFilename); + bool callMainFunction(const std::string &MainName, + const std::vector &InputFilename); void list(); // Do the 'list' command void printStackTrace(); // Do the 'backtrace' command // Code execution methods... - void callMethod(Function *F, const std::vector &ArgVals); + void callFunction(Function *F, const std::vector &ArgVals); bool executeInstruction(); // Execute one instruction... void stepInstruction(); // Do the 'step' command @@ -138,13 +138,13 @@ public: void executeRetInst(ReturnInst &I, ExecutionContext &SF); void executeBrInst(BranchInst &I, ExecutionContext &SF); void executeAllocInst(AllocationInst &I, ExecutionContext &SF); - GenericValue callExternalMethod(Function *F, - const std::vector &ArgVals); + GenericValue callExternalFunction(Function *F, + const std::vector &ArgVals); void exitCalled(GenericValue GV); - // getCurrentMethod - Return the currently executing method - inline Function *getCurrentMethod() const { - return CurFrame < 0 ? 0 : ECStack[CurFrame].CurMethod; + // getCurrentFunction - Return the currently executing function + inline Function *getCurrentFunction() const { + return CurFrame < 0 ? 0 : ECStack[CurFrame].CurFunction; } // isStopped - Return true if a program is stopped. Return false if no @@ -194,7 +194,7 @@ private: // Helper functions void initializeExecutionEngine(); - void initializeExternalMethods(); + void initializeExternalFunctions(); }; #endif diff --git a/lib/ExecutionEngine/Interpreter/Support.cpp b/lib/ExecutionEngine/Interpreter/Support.cpp index 5f4137ce5d9..d857b664f9f 100644 --- a/lib/ExecutionEngine/Interpreter/Support.cpp +++ b/lib/ExecutionEngine/Interpreter/Support.cpp @@ -8,8 +8,6 @@ #include "llvm/SymbolTable.h" #include "llvm/Assembly/Writer.h" #include "llvm/Module.h" -#include -using std::cout; //===----------------------------------------------------------------------===// // @@ -36,9 +34,9 @@ static inline void LookupMatchingNames(const std::string &Name, // std::vector Interpreter::LookupMatchingNames(const std::string &Name) { std::vector Results; - Function *CurMeth = getCurrentMethod(); + Function *CurFunc = getCurrentFunction(); - if (CurMeth) ::LookupMatchingNames(Name, CurMeth->getSymbolTable(), Results); + if (CurFunc) ::LookupMatchingNames(Name, CurFunc->getSymbolTable(), Results); ::LookupMatchingNames(Name, getModule().getSymbolTable(), Results); return Results; } @@ -52,25 +50,26 @@ Value *Interpreter::ChooseOneOption(const std::string &Name, switch (Opts.size()) { case 1: return Opts[0]; case 0: - cout << "Error: no entities named '" << Name << "' found!\n"; + std::cout << "Error: no entities named '" << Name << "' found!\n"; return 0; default: break; // Must prompt user... } - cout << "Multiple entities named '" << Name << "' found! Please choose:\n"; - cout << " 0. Cancel operation\n"; + std::cout << "Multiple entities named '" << Name + << "' found! Please choose:\n"; + std::cout << " 0. Cancel operation\n"; for (unsigned i = 0; i < Opts.size(); ++i) { - cout << " " << (i+1) << "."; - WriteAsOperand(cout, Opts[i]) << "\n"; + std::cout << " " << (i+1) << "."; + WriteAsOperand(std::cout, Opts[i]) << "\n"; } unsigned Option; do { - cout << "lli> " << std::flush; + std::cout << "lli> " << std::flush; std::cin >> Option; if (Option > Opts.size()) - cout << "Invalid selection: Please choose from 0 to " << Opts.size() - << "\n"; + std::cout << "Invalid selection: Please choose from 0 to " << Opts.size() + << "\n"; } while (Option > Opts.size()); if (Option == 0) return 0; diff --git a/lib/ExecutionEngine/Interpreter/UserInput.cpp b/lib/ExecutionEngine/Interpreter/UserInput.cpp index 3d2b1de60a4..0ed0f04b15b 100644 --- a/lib/ExecutionEngine/Interpreter/UserInput.cpp +++ b/lib/ExecutionEngine/Interpreter/UserInput.cpp @@ -10,9 +10,6 @@ #include "llvm/Function.h" #include "llvm/Transforms/Utils/Linker.h" #include -using std::string; -using std::cout; -using std::cin; enum CommandID { Quit, Help, // Basics @@ -29,10 +26,10 @@ static struct CommandTableElement { enum CommandID CID; inline bool operator<(const CommandTableElement &E) const { - return string(Name) < string(E.Name); + return std::string(Name) < std::string(E.Name); } - inline bool operator==(const string &S) const { - return string(Name) == S; + inline bool operator==(const std::string &S) const { + return std::string(Name) == S; } } CommandTable[] = { { "quit" , Quit }, { "q", Quit }, { "", Quit }, // Empty str = eof @@ -76,25 +73,25 @@ void Interpreter::handleUserInput() { printCurrentInstruction(); do { - string Command; - cout << "lli> " << std::flush; - cin >> Command; + std::string Command; + std::cout << "lli> " << std::flush; + std::cin >> Command; CommandTableElement *E = find(CommandTable, CommandTableEnd, Command); if (E == CommandTableEnd) { - cout << "Error: '" << Command << "' not recognized!\n"; + std::cout << "Error: '" << Command << "' not recognized!\n"; continue; } switch (E->CID) { case Quit: UserQuit = true; break; case Print: - cin >> Command; + std::cin >> Command; print(Command); break; case Info: - cin >> Command; + std::cin >> Command; infoValue(Command); break; @@ -102,32 +99,32 @@ void Interpreter::handleUserInput() { case StackTrace: printStackTrace(); break; case Up: if (CurFrame > 0) { --CurFrame; printStackFrame(); } - else cout << "Error: Already at root of stack!\n"; + else std::cout << "Error: Already at root of stack!\n"; break; case Down: if ((unsigned)CurFrame < ECStack.size()-1) { ++CurFrame; printStackFrame(); } else - cout << "Error: Already at bottom of stack!\n"; + std::cout << "Error: Already at bottom of stack!\n"; break; case Next: nextInstruction(); break; case Step: stepInstruction(); break; case Run: run(); break; case Finish: finish(); break; case Call: - cin >> Command; - callMethod(Command); // Enter the specified function + std::cin >> Command; + callFunction(Command); // Enter the specified function finish(); // Run until it's complete break; case TraceOpt: Trace = !Trace; - cout << "Tracing " << (Trace ? "enabled\n" : "disabled\n"); + std::cout << "Tracing " << (Trace ? "enabled\n" : "disabled\n"); break; default: - cout << "Command '" << Command << "' unimplemented!\n"; + std::cout << "Command '" << Command << "' unimplemented!\n"; break; } @@ -137,15 +134,15 @@ void Interpreter::handleUserInput() { //===----------------------------------------------------------------------===// // setBreakpoint - Enable a breakpoint at the specified location // -void Interpreter::setBreakpoint(const string &Name) { +void Interpreter::setBreakpoint(const std::string &Name) { Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name)); // TODO: Set a breakpoint on PickedVal } //===----------------------------------------------------------------------===// -// callMethod - Enter the specified method... +// callFunction - Enter the specified function... // -bool Interpreter::callMethod(const string &Name) { +bool Interpreter::callFunction(const std::string &Name) { std::vector Options = LookupMatchingNames(Name); for (unsigned i = 0; i < Options.size(); ++i) { // Remove non-fn matches... @@ -164,7 +161,7 @@ bool Interpreter::callMethod(const string &Name) { std::vector Args; // TODO, get args from user... - callMethod(F, Args); // Start executing it... + callFunction(F, Args); // Start executing it... // Reset the current frame location to the top of stack CurFrame = ECStack.size()-1; @@ -172,11 +169,11 @@ bool Interpreter::callMethod(const string &Name) { return false; } -// callMainMethod - This is a nasty gross hack that will dissapear when -// callMethod can parse command line options and stuff for us. +// callMainFunction - This is a nasty gross hack that will dissapear when +// callFunction can parse command line options and stuff for us. // -bool Interpreter::callMainMethod(const string &Name, - const std::vector &InputArgv) { +bool Interpreter::callMainFunction(const std::string &Name, + const std::vector &InputArgv) { std::vector Options = LookupMatchingNames(Name); for (unsigned i = 0; i < Options.size(); ++i) { // Remove non-fn matches... @@ -196,7 +193,8 @@ bool Interpreter::callMainMethod(const string &Name, std::vector Args; switch (MT->getParamTypes().size()) { default: - cout << "Unknown number of arguments to synthesize for '" << Name << "'!\n"; + std::cout << "Unknown number of arguments to synthesize for '" << Name + << "'!\n"; return true; case 2: { PointerType *SPP = PointerType::get(PointerType::get(Type::SByteTy)); @@ -211,7 +209,7 @@ bool Interpreter::callMainMethod(const string &Name, // fallthrough case 1: if (!MT->getParamTypes()[0]->isInteger()) { - cout << "First argument of '" << Name << "' should be an integer!\n"; + std::cout << "First argument of '" << Name << "' should be an integer!\n"; return true; } else { GenericValue GV; GV.UIntVal = InputArgv.size(); @@ -222,7 +220,7 @@ bool Interpreter::callMainMethod(const string &Name, break; } - callMethod(M, Args); // Start executing it... + callFunction(M, Args); // Start executing it... // Reset the current frame location to the top of stack CurFrame = ECStack.size()-1; @@ -234,13 +232,13 @@ bool Interpreter::callMainMethod(const string &Name, void Interpreter::list() { if (ECStack.empty()) - cout << "Error: No program executing!\n"; + std::cout << "Error: No program executing!\n"; else - CW << ECStack[CurFrame].CurMethod; // Just print the function out... + CW << ECStack[CurFrame].CurFunction; // Just print the function out... } void Interpreter::printStackTrace() { - if (ECStack.empty()) cout << "No program executing!\n"; + if (ECStack.empty()) std::cout << "No program executing!\n"; for (unsigned i = 0; i < ECStack.size(); ++i) { printStackFrame((int)i); -- 2.34.1