---

param.h

Go to the documentation of this file.

/*
PeRdr - PE file disassembler
Copyright (C) 1999-2002 Frediano Ziglio
-----

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-----

INFORMATION
  www: https://freddy77.tripod.com/perdr/
  e-mail: freddy77@angelfire.com
*/
#ifndef FILE_PARAM_H
#define FILE_PARAM_H

#include "registers.h"
#include "relocationinfo.h"

// class per paramentro
// registro, costante o memoria
// memoria: [costante], [reg], [reg+costante] [reg+reg*n], [reg+reg*n+costante]
// se non c'e' costante mettere 0
class Param
{
public:
#ifdef DEBUG
  void InitInvalid();
  void CheckValid();
#endif
  enum TCRegistry   { Registry };
  enum TCLiteral    { Literal  };
  enum TCFarLiteral { FarLiteral  };
  enum TCMemory     { Memory   };
  enum Types { t_registry, t_literal, t_memory, t_farliteral };
  typedef enum MemoryTypes {
#define DEFINE_MEMTYPE(name,size) name,
#define DEFINE_MEMTYPEI(name,size) name = 0,
#include "memtype.h"
#undef DEFINE_MEMTYPE
#undef DEFINE_MEMTYPEI
    memTypeCount
  } MemoryTypes;
//  std::string GetString() const;
  enum Types GetType() const { return type; };
  Param():relocation(NULL) {};
  // costruttori per registro
  Param(enum TCRegistry dummy,reg_t reg);
  // costruttori per letterali (costanti)
  Param(enum TCLiteral dummy,int _literal,unsigned char _size=0);
  // costruttori per letterali (costanti)
  Param(enum TCFarLiteral dummy,int _literal,unsigned char _size,int segment);
  // costruttori per memoria
  Param(enum TCMemory dummy,int address,MemoryTypes memType = memNone);
  Param(enum TCMemory dummy,reg_t reg,int address=0,MemoryTypes memType = memNone);
  Param(enum TCMemory dummy,reg_t reg1,reg_t reg2,int address=0,unsigned char multiplier=1,MemoryTypes memType = memNone);

//protected:
public:
  bool RegEqual(const Param& rhs) const
  { return type == t_registry && rhs.type == t_registry && mem_reg1 == rhs.mem_reg1; }
//  bool operator==();
  reg_t mem_reg1; // null_reg if not present, set if type registry
  reg_t mem_reg2; // null_reg if not present
  int literal; // 0 if not present
  const Relocation* relocation;  // informazioni rilocazione relative a literal
  enum Types type;
  unsigned char factor; // if mem_reg2 set
  unsigned char GetSize() const;
  unsigned char GetLiteralSize() const
  {
    _PRG_ASSERT( type == t_literal || type == t_farliteral );
    return sm.size;
  };
  unsigned GetMemSize() const
  {
    _PRG_ASSERT( type == t_memory );
    _PRG_ASSERT( unsigned(sm.memType&0x7F) < memTypeCount );
    return memTypeSizes[sm.memType&0x7F];
  };
  void SetMemType(MemoryTypes _memType,bool bWriteSize = true)
  {
    _PRG_ASSERT( type == t_memory );
    _PRG_ASSERT( unsigned(_memType) < memTypeCount );
    _PRG_ASSERT( memTypeCount < 128 );
    sm.memType = (unsigned char)_memType;
    if (!bWriteSize)
      sm.memType |= 0x80;
  };
  bool MustWriteMemSize() const
  {
    _PRG_ASSERT( type == t_memory );
    return (sm.memType & 0x80) == 0;
  }
private:
  union {
  unsigned char size; // 0 if unspecified
  unsigned char memType;
  } sm;
  static unsigned memTypeSizes[memTypeCount];
};

class RegParam: public Param
{
public:
  RegParam(reg_t reg);
};

class LiteralParam: public Param
{
public:
  LiteralParam(int _literal,unsigned char _size=0);
};

class MemoryParam: public Param
{
public:
  MemoryParam(int address,unsigned char size=0);
  MemoryParam(reg_t reg,int address=0,unsigned char size=0);
  MemoryParam(reg_t reg1,reg_t reg2,int address=0,unsigned char multiplier=1,unsigned char size=0);
};

#endif //FILE_PARAM_H

---