interface.hh

Go to the documentation of this file.

/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __INTERFACE__
#define __INTERFACE__
 
#include "capability.hh"
#include <string>
#include <map>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <cstdio>
 
using namespace std;
 
#ifdef __REMOTE_SOCKET__
 
class RemoteSocket {
  int fileDescriptor;       
  basic_filebuf<char> *inbuf;   
  basic_filebuf<char> *outbuf;  
  istream *inStream;        
  ostream *outStream;       
  bool isOpen;          
public:
  RemoteSocket(void);               
  ~RemoteSocket(void) { close(); }      
  bool open(const string &filename);        
  bool isSocketOpen(void);          
  istream *getInputStream(void) { return inStream; }    
  ostream *getOutputStream(void) { return outStream; }  
  void close(void);             
};
 
#endif
 
struct IfaceError {
  string explain;       
  IfaceError(const string &s) { explain = s; }  
};
 
struct IfaceParseError : public IfaceError {
  IfaceParseError(const string &s) : IfaceError(s) {}   
};
 
struct IfaceExecutionError : public IfaceError {
  IfaceExecutionError(const string &s) : IfaceError(s) {}   
};
 
class IfaceStatus;      // Forward declaration
 
class IfaceData {
public:
  virtual ~IfaceData(void) {}       
};
 
class IfaceCommand {
  vector<string> com;       
public:
  virtual ~IfaceCommand(void) {}    
 
  virtual void setData(IfaceStatus *root,IfaceData *data)=0;
 
  virtual void execute(istream &s)=0;
 
  virtual string getModule(void) const=0;
 
  virtual IfaceData *createData(void)=0;
 
  void addWord(const string &temp) { com.push_back(temp); }
 
  void removeWord(void) { com.pop_back(); } 
  const string &getCommandWord(int4 i) const { return com[i]; } 
  void addWords(const vector<string> &wordlist);    
  int4 numWords(void) const { return com.size(); }  
  void commandString(string &res) const;    
  int4 compare(const IfaceCommand &op2) const;  
};
 
class IfaceCommandDummy : public IfaceCommand {
public:
  virtual void setData(IfaceStatus *root,IfaceData *data) {}
  virtual void execute(istream &s) {}
  virtual string getModule(void) const { return "dummy"; }
  virtual IfaceData *createData(void) { return (IfaceData *)0; }
};
 
inline bool compare_ifacecommand(const IfaceCommand *a,const IfaceCommand *b) {
  return (0>a->compare(*b));
}
 
class IfaceCapability : public CapabilityPoint {
  static vector<IfaceCapability *> thelist; 
protected:
  string name;          
public:
  const string &getName(void) const { return name; }    
  virtual void initialize(void);
  virtual void registerCommands(IfaceStatus *status)=0; 
 
  static void registerAllCommands(IfaceStatus *status); 
};
 
 
 
class IfaceStatus {
  vector<string> promptstack;   
  vector<uint4> flagstack;  
  string prompt;        
  int4 maxhistory;      
  int4 curhistory;      
  vector<string> history;   
  bool sorted;          
  bool errorisdone;     
  void restrictCom(vector<IfaceCommand *>::const_iterator &first,
           vector<IfaceCommand *>::const_iterator &last,vector<string> &input);
 
  virtual void readLine(string &line)=0;
  void saveHistory(const string &line);     
protected:
  bool inerror;         
  vector<IfaceCommand *> comlist; 
  map<string,IfaceData *> datamap; 
  int4 expandCom(vector<string> &expand,istream &s,
        vector<IfaceCommand *>::const_iterator &first,
        vector<IfaceCommand *>::const_iterator &last);
public:
  bool done;            
  ostream *optr;        
  ostream *fileoptr;        
 
  IfaceStatus(const string &prmpt,ostream &os,int4 mxhist=10);  
  virtual ~IfaceStatus(void);                   
  void setErrorIsDone(bool val) { errorisdone = val; }  
  virtual void pushScript(const string &filename,const string &newprompt);
  virtual void popScript(void);
  void reset(void); 
  int4 getNumInputStreamSize(void) const { return promptstack.size(); } 
  void writePrompt(void) { *optr << prompt; }   
  void registerCom(IfaceCommand *fptr, const char *nm1,
           const char *nm2 = (const char *)0,
           const char *nm3 = (const char *)0,
           const char *nm4 = (const char *)0,
           const char *nm5 = (const char *)0);
  IfaceData *getData(const string &nm) const;   
  bool runCommand(void);            
  void getHistory(string &line,int4 i) const;   
  int4 getHistorySize(void) const { return history.size(); }    
  virtual bool isStreamFinished(void) const=0;      
  bool isInError(void) const { return inerror; }    
  void evaluateError(void);         
  static void wordsToString(string &res,const vector<string> &list);    
};
 
class IfaceBaseCommand : public IfaceCommand {
protected:
  IfaceStatus *status;      
public:
  virtual void setData(IfaceStatus *root,IfaceData *data) { status = root; }
  virtual string getModule(void) const { return "base"; }
  virtual IfaceData *createData(void) { return (IfaceData *)0; }
};
 
class IfcQuit : public IfaceBaseCommand {
public:
  virtual void execute(istream &s);
};
 
class IfcHistory : public IfaceBaseCommand {
public:
  virtual void execute(istream &s);
};
 
class IfcOpenfile : public IfaceBaseCommand {
public:
  virtual void execute(istream &s);
};
 
class IfcOpenfileAppend : public IfaceBaseCommand {
public:
  virtual void execute(istream &s);
};
 
class IfcClosefile : public IfaceBaseCommand {
public:
  virtual void execute(istream &s);
};
 
class IfcEcho : public IfaceBaseCommand {
public:
  virtual void execute(istream &s);
};
 
#endif