common.i

H.264完整的C语言代码和DCT的代码

#line 62 "D:/working/tools/isim\\libapi.hpp"







#line 70 "D:/working/tools/isim\\libapi.hpp"

#line 72 "D:/working/tools/isim\\libapi.hpp"
#line 28 "D:/working/tools/isim\\string.hpp"

class __declspec(dllexport) String {
  struct srep {
    char *str;     
    int n;         
    srep() { str=0; n=1; }
  };
  srep *p;

  int ok(char *proc, int lineno) const;

 public:
  
  String();

  
  String(const int i, const int base = 10);
  String(const unsigned int i, const int base = 10);
  String(const long i, const int base = 10);
  String(const unsigned long i, const int base = 10);

  
  String(const char c);

  
  String(const char *cs);

  
  String(const String& s);

  ~String();

  
  
  String substring(unsigned int lo, unsigned int hi) const;

  String& operator=(const char *cs);
  String& operator=(const String& s);

  int length() const;

  char& operator[](unsigned i);
  const char& operator[](unsigned i) const;

  String operator+(const char *cs);
  String operator+(const String &s);

  char *char_ptr() const;
  static void delete_char_ptr(char *cs);

  
  void uppercase();
  void lowercase();

  
  int asint() const;

  
  void deleteMyTrailingWhiteSpace();
  void deleteMyLeadingWhiteSpace();

  friend __declspec(dllexport) ostream& operator<<(ostream& os, const String& s);
  friend __declspec(dllexport) istream& operator>>(istream& is, String& s);

  bool operator==(const String& s2) const { 
    return !strcmp(p->str, s2.p->str); 
  }
  bool operator==(const char *s2) const { 
    return !strcmp(p->str, s2); 
  }

  bool operator!=(const String& s2) const {
    return (strcmp(p->str, s2.p->str) != 0);
  }
  bool operator!=(const char *s2) const { 
    return (strcmp(p->str, s2) != 0);
  }

  bool operator<(const String& s2) const { 
    return strcmp(p->str, s2.p->str) < 0; 
  }
  bool operator<(const char *s2) const { 
    return strcmp(p->str, s2) < 0; 
  }
  void streamIO(istream* i, ostream* o, unsigned int indent, 
    bool includeLength = true);
};

#line 117 "D:/working/tools/isim\\string.hpp"

#line 15 "D:/working/tools/common.cpp"
#line 1 "D:/working/tools/common.hpp"




















#line 1 "D:/working/tools/isim\\string.hpp"





















































































































#line 22 "D:/working/tools/common.hpp"
#line 1 "D:/working/tools/isim\\vector.hpp"




















#line 1 "D:/working/tools/isim\\error.hpp"




















#line 1 "D:/working/tools/isim\\string.hpp"





















































































































#line 22 "D:/working/tools/isim\\error.hpp"












void __declspec(dllexport) _error(String file_name, int line_no, String msg);















#line 51 "D:/working/tools/isim\\error.hpp"








#line 60 "D:/working/tools/isim\\error.hpp"
#line 22 "D:/working/tools/isim\\vector.hpp"
#line 1 "D:/working/tools/isim\\libapi.hpp"







































































#line 23 "D:/working/tools/isim\\vector.hpp"

#pragma warning( disable : 4284 )
#pragma warning(disable: 4786)








template<class T> class vector;

template<class T>
class VPtr {
  int        idx;
  vector<T> *v;

 public:
  VPtr(): idx(-1), v(0) {}
  VPtr(const VPtr& p);

  ~VPtr() { idx = -1; v = 0; }

  VPtr& operator=(const VPtr& p);

  VPtr& operator++();
  
  VPtr& operator--();
  

  T& operator*();
  T *operator->();

  bool valid();

  bool operator==(const VPtr& p);
  bool operator!=(const VPtr& p);
  
  bool operator<(const VPtr& p);
  bool operator>(const VPtr& p);

  friend class vector<T>;
};

struct __declspec(dllexport) portable_vector {
  void *data;    
  int   datasz;  

  int   len;     

  portable_vector(): data(0), datasz(0), len(0) {}

  void (*delop)(void*);
};


template<class T>
class vector {
  T  *data;
  unsigned int sz;
  unsigned int used;
  void (*delop)(void*);

  inline T   *allocate(unsigned int n);  
  inline void destroy();                 

  void copy(const vector& v);

 public:
  vector();
  vector(const unsigned int n, const T& el = T());
  vector(const vector& v);
  vector(const portable_vector& pv);
  ~vector();

  void clear_portable_vector(portable_vector& pv);

  vector& operator=(const vector& v);

  int size() const { return used; }
  void clear();

  T& back();
  T& front();
  void push_back(const T& el);
  void push_back(const vector<T>& v);
  


  T pop_back();

  inline T& operator[](const unsigned int i);
  inline const T& operator[](const unsigned int i) const;

  VPtr<T> begin();
  VPtr<T> end();
  VPtr<T> getPtr(const unsigned int i); 

  operator portable_vector() const;

  
  
  
  char* writeBin(const unsigned int bin_size);
  
  
  char* readBin(unsigned int& bin_size);

  friend class VPtr<T>;
};










#line 1 "D:/working/tools/isim\\vector.cpp"




#line 1 "D:/Progra~1/Micros~2/VC98/Include\\assert.h"















#line 17 "D:/Progra~1/Micros~2/VC98/Include\\assert.h"



















#line 37 "D:/Progra~1/Micros~2/VC98/Include\\assert.h"































#line 69 "D:/Progra~1/Micros~2/VC98/Include\\assert.h"
#line 6 "D:/working/tools/isim\\vector.cpp"
#line 1 "D:/Progra~1/Micros~2/VC98/Include\\new.h"













#pragma once
#line 16 "D:/Progra~1/Micros~2/VC98/Include\\new.h"












#line 29 "D:/Progra~1/Micros~2/VC98/Include\\new.h"



















#line 49 "D:/Progra~1/Micros~2/VC98/Include\\new.h"




















typedef void (__cdecl * new_handler) ();
 new_handler __cdecl set_new_handler(new_handler);
#line 72 "D:/Progra~1/Micros~2/VC98/Include\\new.h"



inline void *__cdecl operator new(size_t, void *_P)
        {return (_P); }

inline void __cdecl operator delete(void *, void *)
	{return; }
#line 81 "D:/Progra~1/Micros~2/VC98/Include\\new.h"
#line 82 "D:/Progra~1/Micros~2/VC98/Include\\new.h"






 int __cdecl _query_new_mode( void );
 int __cdecl _set_new_mode( int );


typedef int (__cdecl * _PNH)( size_t );

#line 95 "D:/Progra~1/Micros~2/VC98/Include\\new.h"

 _PNH __cdecl _query_new_handler( void );