cfad47cfa3/tads3/vmsa.cpp

Show revision log
 
4b825dc642cb6eb9a060e54bf8d69288fbee4904cfad47cfa334b206c65f22086bcc5d63e6f70944
1
#ifdef RCSID



2
static char RCSid[] =



3
"$Header$";



4
#endif



5



6
/* 



7
 *   Copyright (c) 1999, 2002 Michael J. Roberts.  All Rights Reserved.



8
 *   



9
 *   Please see the accompanying license file, LICENSE.TXT, for information



10
 *   on using and copying this software.  



11
 */



12
/*



13
Name



14
  vmsa.cpp - stand-alone interpreter entrypoints



15
Function



16
  Defines certain entrypoints that are not needed in a normal stand-alone



17
  version of the interpreter.  The entrypoints defined here are dummy



18
  implementations that should never be called.



19



20
  Certain functions are needed only in special VM versions that support,



21
  for example, rebuilding of an image file after running 'preinit'.



22
Notes



23
  



24
Modified



25
  07/21/99 MJRoberts  - Creation



26
*/



27



28
#include <assert.h>



29



30
#include "vmobj.h"



31
#include "vmglob.h"



32
#include "vmdict.h"



33
#include "vmstr.h"



34
#include "vmlst.h"



35
#include "vmbignum.h"



36
#include "vmtobj.h"



37
#include "vmgram.h"



38
#include "vmmeta.h"



39
#include "vmintcls.h"



40
#include "vmiter.h"



41
#include "vmvec.h"



42
#include "vmlookup.h"



43
#include "vmbytarr.h"



44
#include "vmcset.h"



45
#include "vmfilobj.h"



46
#include "vmpat.h"



47
#include "vmstrcmp.h"



48



49



50
ulong CVmObjTads::rebuild_image(VMG_ char *, ulong)



51
{



52
    assert(FALSE);



53
    return 0;



54
}



55



56
void CVmObjTads::convert_to_const_data(VMG_ CVmConstMapper *,



57
                                       vm_obj_id_t)



58
{



59
    assert(FALSE);



60
}



61



62
ulong CVmObjString::rebuild_image(VMG_ char *, ulong)



63
{



64
    assert(FALSE);



65
    return 0;



66
}



67



68
void CVmObjString::reserve_const_data(VMG_ CVmConstMapper *,



69
                                      vm_obj_id_t)



70
{



71
    assert(FALSE);



72
}



73



74
void CVmObjString::convert_to_const_data(VMG_ CVmConstMapper *,



75
                                         vm_obj_id_t)



76
{



77
    assert(FALSE);



78
}



79



80
ulong CVmObjList::rebuild_image(VMG_ char *, ulong)



81
{



82
    assert(FALSE);



83
    return 0;



84
}



85



86
void CVmObjList::reserve_const_data(VMG_ CVmConstMapper *,



87
                                    vm_obj_id_t)



88
{



89
    assert(FALSE);



90
}



91



92
void CVmObjList::convert_to_const_data(VMG_ CVmConstMapper *,



93
                                       vm_obj_id_t)



94
{



95
    assert(FALSE);



96
}



97



98
ulong CVmObjDict::rebuild_image(VMG_ char *, ulong)



99
{



100
    assert(FALSE);



101
    return 0;



102
}



103



104
void CVmObjDict::convert_to_const_data(VMG_ CVmConstMapper *,



105
                                       vm_obj_id_t)



106
{



107
    assert(FALSE);



108
}



109



110
ulong CVmObjGramProd::rebuild_image(VMG_ char *buf, ulong buflen)



111
{



112
    assert(FALSE);



113
    return 0;



114
}



115



116
void CVmMetaTable::rebuild_image(class CVmImageWriter *)



117
{



118
}



119



120
ulong CVmObjBigNum::rebuild_image(VMG_ char *, ulong)



121
{



122
    assert(FALSE);



123
    return 0;



124
}



125



126
void CVmObjBigNum::reserve_const_data(VMG_ CVmConstMapper *,



127
                                      vm_obj_id_t)



128
{



129
    assert(FALSE);



130
}



131



132
void CVmObjBigNum::convert_to_const_data(VMG_ CVmConstMapper *,



133
                                         vm_obj_id_t)



134
{



135
    assert(FALSE);



136
}



137



138
ulong CVmObjClass::rebuild_image(VMG_ char *, ulong)



139
{



140
    assert(FALSE);



141
    return 0;



142
}



143



144
ulong CVmObjIterIdx::rebuild_image(VMG_ char *, ulong)



145
{



146
    assert(FALSE);



147
    return 0;



148
}



149



150
void CVmObjIterIdx::convert_to_const_data(VMG_ CVmConstMapper *,



151
                                          vm_obj_id_t)



152
{



153
    assert(FALSE);



154
}



155



156
ulong CVmObjVector::rebuild_image(VMG_ char *, ulong)



157
{



158
    assert(FALSE);



159
    return 0;



160
}



161



162
void CVmObjVector::reserve_const_data(VMG_ CVmConstMapper *, vm_obj_id_t)



163
{



164
    assert(FALSE);



165
}



166



167
void CVmObjVector::convert_to_const_data(VMG_ CVmConstMapper *, vm_obj_id_t)



168
{



169
    assert(FALSE);



170
}



171



172
ulong CVmObjLookupTable::rebuild_image(VMG_ char *, ulong)



173
{



174
    assert(FALSE);



175
    return 0;



176
}



177



178
void CVmObjLookupTable::convert_to_const_data(VMG_ CVmConstMapper *,



179
                                              vm_obj_id_t)



180
{



181
    assert(FALSE);



182
}



183



184
ulong CVmObjIterLookupTable::rebuild_image(VMG_ char *, ulong)



185
{



186
    assert(FALSE);



187
    return 0;



188
}



189



190
void CVmObjIterLookupTable::convert_to_const_data(



191
    VMG_ CVmConstMapper *, vm_obj_id_t)



192
{



193
    assert(FALSE);



194
}



195



196
ulong CVmObjByteArray::rebuild_image(VMG_ char *, ulong)



197
{



198
    assert(FALSE);



199
    return 0;



200
}



201



202
ulong CVmObjCharSet::rebuild_image(VMG_ char *, ulong)



203
{



204
    assert(FALSE);



205
    return 0;



206
}



207



208
ulong CVmObjFile::rebuild_image(VMG_ char *, ulong)



209
{



210
    assert(FALSE);



211
    return 0;



212
}



213



214
ulong CVmObjPattern::rebuild_image(VMG_ char *, ulong)



215
{



216
    assert(FALSE);



217
    return 0;



218
}



219



220
void CVmObjPattern::convert_to_const_data(VMG_ CVmConstMapper *, vm_obj_id_t)



221
{



222
    assert(FALSE);



223
}



224



225
ulong CVmObjStrComp::rebuild_image(VMG_ char *, ulong)



226
{



227
    assert(FALSE);



228
    return 0;



229
}