1 /* ScummVM - Graphic Adventure Engine 2 * 3 * ScummVM is the legal property of its developers, whose names 4 * are too numerous to list here. Please refer to the COPYRIGHT 5 * file distributed with this source distribution. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2 10 * of the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 20 * 21 */ 22 23 #ifndef SCI_ENGINE_KERNEL_TABLES_H 24 #define SCI_ENGINE_KERNEL_TABLES_H 25 26 #include "sci/engine/workarounds.h" 27 #include "sci/engine/vm_types.h" // for opcode_formats 28 29 namespace Sci { 30 31 // [io] -> either integer or object 32 // (io) -> optionally integer AND an object 33 // (i) -> optional integer 34 // . -> any type 35 // i* -> optional multiple integers 36 // .* -> any parameters afterwards (or none) 37 // 38 // data types: 39 // i - regular integer 40 // o - object 41 // r - reference 42 // l - list 43 // n - node 44 // 0 - NULL 45 // . - any 46 // ! - invalid reference/offset 47 48 struct SciKernelMapSubEntry { 49 SciVersion fromVersion; 50 SciVersion toVersion; 51 52 uint16 id; 53 54 const char *name; 55 KernelFunctionCall *function; 56 57 const char *signature; 58 const SciWorkaroundEntry *workarounds; 59 }; 60 61 #define SCI_SUBOPENTRY_TERMINATOR { SCI_VERSION_NONE, SCI_VERSION_NONE, 0, NULL, NULL, NULL, NULL } 62 63 64 #define SIG_SCIALL SCI_VERSION_NONE, SCI_VERSION_NONE 65 #define SIG_SCI0 SCI_VERSION_NONE, SCI_VERSION_01 66 #define SIG_SCI1 SCI_VERSION_1_EGA_ONLY, SCI_VERSION_1_LATE 67 #define SIG_SCI11 SCI_VERSION_1_1, SCI_VERSION_1_1 68 #define SIG_SINCE_SCI11 SCI_VERSION_1_1, SCI_VERSION_NONE 69 #define SIG_SCI2 SCI_VERSION_2, SCI_VERSION_2 70 #define SIG_SCI21EARLY SCI_VERSION_2_1_EARLY, SCI_VERSION_2_1_EARLY 71 #define SIG_SCI21MID SCI_VERSION_2_1_MIDDLE, SCI_VERSION_2_1_MIDDLE 72 #define SIG_SCI21MID_LATE SCI_VERSION_2_1_MIDDLE, SCI_VERSION_2_1_LATE 73 #define SIG_THRU_SCI21EARLY SCI_VERSION_2, SCI_VERSION_2_1_EARLY 74 #define SIG_THRU_SCI21MID SCI_VERSION_2, SCI_VERSION_2_1_MIDDLE 75 #define SIG_SINCE_SCI21 SCI_VERSION_2_1_EARLY, SCI_VERSION_3 76 #define SIG_SINCE_SCI21MID SCI_VERSION_2_1_MIDDLE, SCI_VERSION_3 77 #define SIG_SINCE_SCI21LATE SCI_VERSION_2_1_LATE, SCI_VERSION_3 78 #define SIG_SCI21LATE SCI_VERSION_2_1_LATE, SCI_VERSION_2_1_LATE 79 #define SIG_SCI3 SCI_VERSION_3, SCI_VERSION_3 80 81 #define SIG_SCI16 SCI_VERSION_NONE, SCI_VERSION_1_1 82 #define SIG_SCI32 SCI_VERSION_2, SCI_VERSION_NONE 83 84 // SCI-Sound-Version 85 #define SIG_SOUNDSCI0 SCI_VERSION_0_EARLY, SCI_VERSION_0_LATE 86 #define SIG_SOUNDSCI1EARLY SCI_VERSION_1_EARLY, SCI_VERSION_1_EARLY 87 #define SIG_SOUNDSCI1LATE SCI_VERSION_1_LATE, SCI_VERSION_1_LATE 88 89 #define SIGFOR_ALL 0x3f 90 #define SIGFOR_DOS 1 << 0 91 #define SIGFOR_PC98 1 << 1 92 #define SIGFOR_WIN 1 << 2 93 #define SIGFOR_MAC 1 << 3 94 #define SIGFOR_AMIGA 1 << 4 95 #define SIGFOR_ATARI 1 << 5 96 #define SIGFOR_PC SIGFOR_DOS|SIGFOR_WIN 97 98 #define SIG_EVERYWHERE SIG_SCIALL, SIGFOR_ALL 99 100 #define MAP_CALL(_name_) #_name_, k##_name_ 101 #define MAP_EMPTY(_name_) #_name_, kEmpty 102 #define MAP_DUMMY(_name_) #_name_, kDummy 103 104 // version, subId, function-mapping, signature, workarounds 105 static const SciKernelMapSubEntry kDoSound_subops[] = { 106 { SIG_SOUNDSCI0, 0, MAP_CALL(DoSoundInit), "o", NULL }, 107 { SIG_SOUNDSCI0, 1, MAP_CALL(DoSoundPlay), "o", NULL }, 108 { SIG_SOUNDSCI0, 2, MAP_EMPTY(DoSoundRestore), "(o)", NULL }, 109 { SIG_SOUNDSCI0, 3, MAP_CALL(DoSoundDispose), "o", NULL }, 110 { SIG_SOUNDSCI0, 4, MAP_CALL(DoSoundMute), "(i)", NULL }, 111 { SIG_SOUNDSCI0, 5, MAP_CALL(DoSoundStop), "o", NULL }, 112 { SIG_SOUNDSCI0, 6, MAP_CALL(DoSoundPause), "i", NULL }, 113 { SIG_SOUNDSCI0, 7, MAP_CALL(DoSoundResumeAfterRestore), "", NULL }, 114 { SIG_SOUNDSCI0, 8, MAP_CALL(DoSoundMasterVolume), "(i)", NULL }, 115 { SIG_SOUNDSCI0, 9, MAP_CALL(DoSoundUpdate), "o", NULL }, 116 { SIG_SOUNDSCI0, 10, MAP_CALL(DoSoundFade), "[o0]", kDoSoundFade_workarounds }, 117 { SIG_SOUNDSCI0, 11, MAP_CALL(DoSoundGetPolyphony), "", NULL }, 118 { SIG_SOUNDSCI0, 12, MAP_CALL(DoSoundStopAll), "", NULL }, 119 { SIG_SOUNDSCI1EARLY, 0, MAP_CALL(DoSoundMasterVolume), NULL, NULL }, 120 { SIG_SOUNDSCI1EARLY, 1, MAP_CALL(DoSoundMute), NULL, NULL }, 121 { SIG_SOUNDSCI1EARLY, 2, MAP_EMPTY(DoSoundRestore), NULL, NULL }, 122 { SIG_SOUNDSCI1EARLY, 3, MAP_CALL(DoSoundGetPolyphony), NULL, NULL }, 123 { SIG_SOUNDSCI1EARLY, 4, MAP_CALL(DoSoundUpdate), NULL, NULL }, 124 { SIG_SOUNDSCI1EARLY, 5, MAP_CALL(DoSoundInit), NULL, NULL }, 125 { SIG_SOUNDSCI1EARLY, 6, MAP_CALL(DoSoundDispose), NULL, NULL }, 126 { SIG_SOUNDSCI1EARLY, 7, MAP_CALL(DoSoundPlay), "oi", NULL }, 127 { SIG_SOUNDSCI1EARLY, 8, MAP_CALL(DoSoundStop), NULL, NULL }, 128 { SIG_SOUNDSCI1EARLY, 9, MAP_CALL(DoSoundPause), "[o0]i", NULL }, 129 { SIG_SOUNDSCI1EARLY, 10, MAP_CALL(DoSoundFade), "oiiii", kDoSoundFade_workarounds }, 130 { SIG_SOUNDSCI1EARLY, 11, MAP_CALL(DoSoundUpdateCues), "o", NULL }, 131 { SIG_SOUNDSCI1EARLY, 12, MAP_CALL(DoSoundSendMidi), "oiii", NULL }, 132 { SIG_SOUNDSCI1EARLY, 13, MAP_CALL(DoSoundGlobalReverb), "(i)", NULL }, 133 { SIG_SOUNDSCI1EARLY, 14, MAP_CALL(DoSoundSetHold), "oi", NULL }, 134 { SIG_SOUNDSCI1EARLY, 15, MAP_EMPTY(DoSoundDummy), "", NULL }, 135 // ^^ Longbow demo 136 { SIG_SOUNDSCI1LATE, 0, MAP_CALL(DoSoundMasterVolume), NULL, NULL }, 137 { SIG_SOUNDSCI1LATE, 1, MAP_CALL(DoSoundMute), NULL, NULL }, 138 { SIG_SOUNDSCI1LATE, 2, MAP_EMPTY(DoSoundRestore), "", NULL }, 139 { SIG_SOUNDSCI1LATE, 3, MAP_CALL(DoSoundGetPolyphony), NULL, NULL }, 140 { SIG_SOUNDSCI1LATE, 4, MAP_CALL(DoSoundGetAudioCapability), "", NULL }, 141 { SIG_SOUNDSCI1LATE, 5, MAP_CALL(DoSoundSuspend), "i", NULL }, 142 { SIG_SOUNDSCI1LATE, 6, MAP_CALL(DoSoundInit), NULL, NULL }, 143 { SIG_SOUNDSCI1LATE, 7, MAP_CALL(DoSoundDispose), NULL, NULL }, 144 { SIG_SOUNDSCI1LATE, 8, MAP_CALL(DoSoundPlay), NULL, NULL }, 145 { SIG_SOUNDSCI1LATE, 9, MAP_CALL(DoSoundStop), NULL, NULL }, 146 { SIG_SOUNDSCI1LATE, 10, MAP_CALL(DoSoundPause), NULL, NULL }, 147 { SIG_SOUNDSCI1LATE, 11, MAP_CALL(DoSoundFade), "oiiii(i)", kDoSoundFade_workarounds }, 148 { SIG_SOUNDSCI1LATE, 12, MAP_CALL(DoSoundSetHold), NULL, NULL }, 149 { SIG_SOUNDSCI1LATE, 13, MAP_EMPTY(DoSoundDummy), NULL, NULL }, 150 { SIG_SOUNDSCI1LATE, 14, MAP_CALL(DoSoundSetVolume), "oi", NULL }, 151 { SIG_SOUNDSCI1LATE, 15, MAP_CALL(DoSoundSetPriority), "oi", NULL }, 152 { SIG_SOUNDSCI1LATE, 16, MAP_CALL(DoSoundSetLoop), "oi", NULL }, 153 { SIG_SOUNDSCI1LATE, 17, MAP_CALL(DoSoundUpdateCues), NULL, NULL }, 154 { SIG_SOUNDSCI1LATE, 18, MAP_CALL(DoSoundSendMidi), "oiii(i)", NULL }, 155 { SIG_SOUNDSCI1LATE, 19, MAP_CALL(DoSoundGlobalReverb), NULL, NULL }, 156 { SIG_SOUNDSCI1LATE, 20, MAP_CALL(DoSoundUpdate), NULL, NULL }, 157 #ifdef ENABLE_SCI32 158 { SIG_SCI32, 0, MAP_CALL(DoSoundMasterVolume), "(i)", NULL }, 159 { SIG_SCI32, 1, MAP_CALL(DoSoundMute), "(i)", NULL }, 160 { SIG_SCI32, 2, MAP_EMPTY(DoSoundRestore), NULL, NULL }, 161 { SIG_SCI32, 3, MAP_CALL(DoSoundGetPolyphony), "", NULL }, 162 { SIG_SCI32, 4, MAP_CALL(DoSoundGetAudioCapability), "", NULL }, 163 { SIG_SCI32, 5, MAP_CALL(DoSoundSuspend), "i", NULL }, 164 { SIG_SCI32, 6, MAP_CALL(DoSoundInit), "o", NULL }, 165 { SIG_SCI32, 7, MAP_CALL(DoSoundDispose), "o", NULL }, 166 { SIG_SCI32, 8, MAP_CALL(DoSoundPlay), "o", kDoSoundPlay_workarounds }, 167 { SIG_SCI32, 9, MAP_CALL(DoSoundStop), "o", NULL }, 168 { SIG_SCI32, 10, MAP_CALL(DoSoundPause), "[o0]i", NULL }, 169 { SIG_SCI32, 11, MAP_CALL(DoSoundFade), "oiiii", kDoSoundFade_workarounds }, 170 { SIG_SCI32, 12, MAP_CALL(DoSoundSetHold), "oi", NULL }, 171 { SIG_SCI32, 13, MAP_EMPTY(DoSoundDummy), NULL, NULL }, 172 { SIG_SCI32, 14, MAP_CALL(DoSoundSetVolume), "oi", NULL }, 173 { SIG_SCI32, 15, MAP_CALL(DoSoundSetPriority), "oi", NULL }, 174 { SIG_SCI32, 16, MAP_CALL(DoSoundSetLoop), "oi", NULL }, 175 { SIG_SCI32, 17, MAP_CALL(DoSoundUpdateCues), "o", NULL }, 176 { SIG_SCI32, 18, MAP_CALL(DoSoundSendMidi), "oiiii", NULL }, 177 { SIG_SCI32, 19, MAP_CALL(DoSoundGlobalReverb), "(i)", NULL }, 178 { SIG_SCI32, 20, MAP_CALL(DoSoundUpdate), "o", NULL }, 179 #endif 180 SCI_SUBOPENTRY_TERMINATOR 181 }; 182 183 #ifdef ENABLE_SCI32 184 // NOTE: In SSCI, some 'unused' kDoAudio subops are actually called indirectly 185 // by kDoSound: 186 // 187 // kDoSoundGetAudioCapability -> kDoAudioGetCapability 188 // kDoSoundPlay -> kDoAudioPlay, kDoAudioStop 189 // kDoSoundPause -> kDoAudioPause, kDoAudioResume 190 // kDoSoundFade -> kDoAudioFade 191 // kDoSoundSetVolume -> kDoAudioVolume 192 // kDoSoundSetLoop -> kDoAudioSetLoop 193 // kDoSoundUpdateCues -> kDoAudioPosition 194 // 195 // In ScummVM, logic inside these kernel functions has been moved to methods of 196 // Audio32, and direct calls to Audio32 are made from kDoSound instead. 197 // 198 // Some kDoAudio methods are esoteric and appear to be used only by one or two 199 // games: 200 // 201 // - kDoAudioMixing: Phantasmagoria (other games call this function, but only 202 // to disable the feature) 203 // - kDoAudioHasSignal: SQ6 TalkRandCycle 204 // - kDoAudioPan: Rama RegionSFX::pan method 205 // - kDoAudioCritical: Phantasmagoria, chapter 3, nursery (room 14200), during 206 // the "ghost lullaby" event. It is used to make the 207 // lullaby sound exclusive, but it really doesn't make any 208 // major difference. Returning 0 means "non-critical", i.e. 209 // normal audio behavior. 210 // 211 // Finally, there is a split in SCI2.1mid audio code. QFG4CD & SQ6 do not have 212 // opcodes 18 and 19, but they exist in GK2, KQ7 2.00b, Phantasmagoria 1, 213 // PQ:SWAT, and Torin. It is unknown if they exist in MUMG Deluxe or Shivers 1; 214 // they are not used in either of these games. 215 216 // version, subId, function-mapping, signature, workarounds 217 static const SciKernelMapSubEntry kDoAudio_subops[] = { 218 { SIG_SCI32, 0, MAP_CALL(DoAudioInit), "", NULL }, 219 // SCI2 includes a Sync script that would call 220 // kDoAudioWaitForPlay, but SSCI has no opcode 1 until 221 // SCI2.1early 222 { SIG_SINCE_SCI21, 1, MAP_CALL(DoAudioWaitForPlay), "(i)(i)(i)(i)(i)(i)(i)", NULL }, 223 // LSL6 hires Mac passes an extra filename string parameter to play AIFF files 224 { SIG_SCI32, 2, MAP_CALL(DoAudioPlay), "(i)(i)(i)(i)(i)([ir])(i)", NULL }, 225 { SIG_SCI32, 3, MAP_CALL(DoAudioStop), "(i)(i)(i)(i)(i)(r)", NULL }, 226 { SIG_SCI32, 4, MAP_CALL(DoAudioPause), "(i)(i)(i)(i)(i)(r)", NULL }, 227 { SIG_SCI32, 5, MAP_CALL(DoAudioResume), "(i)(i)(i)(i)(i)(r)", kDoAudioResume_workarounds }, 228 { SIG_SCI32, 6, MAP_CALL(DoAudioPosition), "(i)(i)(i)(i)(i)(r)", NULL }, 229 { SIG_SCI32, 7, MAP_CALL(DoAudioRate), "(i)", NULL }, 230 { SIG_SCI32, 8, MAP_CALL(DoAudioVolume), "(i)(i)(i)(i)(i)(i)", NULL }, 231 { SIG_SCI32, 9, MAP_CALL(DoAudioGetCapability), "", NULL }, 232 { SIG_SCI32, 10, MAP_CALL(DoAudioBitDepth), "(i)", NULL }, 233 { SIG_SCI32, 11, MAP_DUMMY(DoAudioDistort), "(i)", NULL }, 234 { SIG_SCI32, 12, MAP_CALL(DoAudioMixing), "(i)", NULL }, 235 { SIG_SCI2, 13, MAP_EMPTY(DoAudioSetBufferSize), "i", NULL }, 236 { SIG_SINCE_SCI21, 13, MAP_CALL(DoAudioChannels), "(i)", NULL }, 237 { SIG_SINCE_SCI21, 14, MAP_CALL(DoAudioPreload), "(i)", NULL }, 238 { SIG_SINCE_SCI21MID, 15, MAP_CALL(DoAudioFade), "(iiii)(i)(i)", NULL }, 239 { SIG_SINCE_SCI21MID, 16, MAP_DUMMY(DoAudioFade36), "iiiii(iii)(i)", NULL }, 240 { SIG_SINCE_SCI21MID, 17, MAP_CALL(DoAudioHasSignal), "", NULL }, 241 { SIG_SINCE_SCI21MID, 18, MAP_EMPTY(DoAudioCritical), "(i)", NULL }, 242 { SIG_SINCE_SCI21MID, 19, MAP_CALL(DoAudioSetLoop), "iii(o)", NULL }, 243 { SIG_SINCE_SCI21LATE,20, MAP_CALL(DoAudioPan), "ii(i)(iii)", NULL }, 244 { SIG_SINCE_SCI21LATE,21, MAP_CALL(DoAudioPanOff), "i(i)(iii)", NULL }, 245 SCI_SUBOPENTRY_TERMINATOR 246 }; 247 #endif 248 249 // version, subId, function-mapping, signature, workarounds 250 static const SciKernelMapSubEntry kGraph_subops[] = { 251 // 1 - load bits 252 { SIG_SCIALL, 2, MAP_CALL(GraphGetColorCount), "", NULL }, 253 // 3 - set palette via resource 254 { SIG_SCIALL, 4, MAP_CALL(GraphDrawLine), "iiiii(i)(i)", kGraphDrawLine_workarounds }, 255 // 5 - nop 256 // 6 - draw pattern 257 { SIG_SCIALL, 7, MAP_CALL(GraphSaveBox), "iiiii", kGraphSaveBox_workarounds }, 258 { SIG_SCIALL, 8, MAP_CALL(GraphRestoreBox), "[r0!]", kGraphRestoreBox_workarounds }, 259 // ^ this may get called with invalid references, we check them within restoreBits() and sierra sci behaves the same 260 { SIG_SCIALL, 9, MAP_CALL(GraphFillBoxBackground), "iiii", NULL }, 261 { SIG_SCIALL, 10, MAP_CALL(GraphFillBoxForeground), "iiii", kGraphFillBoxForeground_workarounds }, 262 { SIG_SCIALL, 11, MAP_CALL(GraphFillBoxAny), "iiiiii(i)(i)", kGraphFillBoxAny_workarounds }, 263 { SIG_SCI11, 12, MAP_CALL(GraphUpdateBox), "iiii(i)(r0)", kGraphUpdateBox_workarounds }, // kq6 hires 264 { SIG_SCIALL, 12, MAP_CALL(GraphUpdateBox), "iiii(i)", kGraphUpdateBox_workarounds }, 265 { SIG_SCIALL, 13, MAP_CALL(GraphRedrawBox), "iiii", kGraphRedrawBox_workarounds }, 266 { SIG_SCIALL, 14, MAP_CALL(GraphAdjustPriority), "ii", NULL }, 267 { SIG_SCI11, 15, MAP_CALL(GraphSaveUpscaledHiresBox), "iiii", NULL }, // kq6 hires 268 SCI_SUBOPENTRY_TERMINATOR 269 }; 270 271 // version, subId, function-mapping, signature, workarounds 272 static const SciKernelMapSubEntry kPalVary_subops[] = { 273 { SIG_SCI16, 0, MAP_CALL(PalVaryInit), "ii(i)(i)", NULL }, 274 { SIG_SCI16, 1, MAP_CALL(PalVaryReverse), "(i)(i)(i)", NULL }, 275 { SIG_SCI16, 2, MAP_CALL(PalVaryGetCurrentStep), "", NULL }, 276 { SIG_SCI16, 3, MAP_CALL(PalVaryDeinit), "", NULL }, 277 { SIG_SCI16, 4, MAP_CALL(PalVaryChangeTarget), "i", NULL }, 278 { SIG_SCI16, 5, MAP_CALL(PalVaryChangeTicks), "i", NULL }, 279 { SIG_SCI16, 6, MAP_CALL(PalVaryPauseResume), "i", NULL }, 280 #ifdef ENABLE_SCI32 281 { SIG_SCI32, 0, MAP_CALL(PalVarySetVary), "i(i)(i)(i)(i)", kPalVarySetVary_workarounds }, 282 { SIG_SCI32, 1, MAP_CALL(PalVarySetPercent), "(i)(i)", kPalVarySetPercent_workarounds }, 283 { SIG_SCI32, 2, MAP_CALL(PalVaryGetPercent), "", NULL }, 284 { SIG_SCI32, 3, MAP_CALL(PalVaryOff), "", NULL }, 285 { SIG_SCI32, 4, MAP_CALL(PalVaryMergeTarget), "i", NULL }, 286 { SIG_SCI32, 5, MAP_CALL(PalVarySetTime), "i", NULL }, 287 { SIG_SCI32, 6, MAP_CALL(PalVaryPauseResume), "i", NULL }, 288 { SIG_SCI32, 7, MAP_CALL(PalVarySetTarget), "i", NULL }, 289 { SIG_SCI32, 8, MAP_CALL(PalVarySetStart), "i", kPalVarySetStart_workarounds }, 290 { SIG_SCI32, 9, MAP_CALL(PalVaryMergeStart), "i", kPalVaryMergeStart_workarounds }, 291 #endif 292 SCI_SUBOPENTRY_TERMINATOR 293 }; 294 295 // version, subId, function-mapping, signature, workarounds 296 static const SciKernelMapSubEntry kPalette_subops[] = { 297 { SIG_SCI16, 1, MAP_CALL(PaletteSetFromResource), "i(i)", NULL }, 298 { SIG_SCI16, 2, MAP_CALL(PaletteSetFlag), "iii", NULL }, 299 { SIG_SCI16, 3, MAP_CALL(PaletteUnsetFlag), "iii", kPaletteUnsetFlag_workarounds }, 300 { SIG_SCI16, 4, MAP_CALL(PaletteSetIntensity), "iii(i)", NULL }, 301 { SIG_SCI16, 5, MAP_CALL(PaletteFindColor), "iii", NULL }, 302 { SIG_SCI16, 6, MAP_CALL(PaletteAnimate), "i*", NULL }, 303 { SIG_SCI16, 7, MAP_CALL(PaletteSave), "", NULL }, 304 { SIG_SCI16, 8, MAP_CALL(PaletteRestore), "[r0]", NULL }, 305 #ifdef ENABLE_SCI32 306 { SIG_SCI32, 1, MAP_CALL(PaletteSetFromResource32), "i(i)", NULL }, 307 { SIG_SCI32, 2, MAP_CALL(PaletteSetFade), "iii", NULL }, 308 { SIG_SCI32, 3, MAP_CALL(PaletteFindColor32), "iii", NULL }, 309 { SIG_SCI32, 4, MAP_CALL(PaletteSetGamma), "i", NULL }, 310 #endif 311 SCI_SUBOPENTRY_TERMINATOR 312 }; 313 314 // version, subId, function-mapping, signature, workarounds 315 static const SciKernelMapSubEntry kFileIO_subops[] = { 316 { SIG_SCIALL, 0, MAP_CALL(FileIOOpen), "ri", kFileIOOpen_workarounds }, 317 { SIG_SCIALL, 1, MAP_CALL(FileIOClose), "i", NULL }, 318 { SIG_SCIALL, 2, MAP_CALL(FileIOReadRaw), "iri", NULL }, 319 { SIG_SCIALL, 3, MAP_CALL(FileIOWriteRaw), "iri", NULL }, 320 { SIG_SCIALL, 4, MAP_CALL(FileIOUnlink), "r", NULL }, 321 { SIG_SCIALL, 5, MAP_CALL(FileIOReadString), "rii", kFileIOReadString_workarounds }, 322 { SIG_SCIALL, 6, MAP_CALL(FileIOWriteString), "ir", NULL }, 323 { SIG_SCIALL, 7, MAP_CALL(FileIOSeek), "iii", NULL }, 324 { SIG_SCIALL, 8, MAP_CALL(FileIOFindFirst), "rri", NULL }, 325 { SIG_SCIALL, 9, MAP_CALL(FileIOFindNext), "r", NULL }, 326 { SIG_SCIALL, 10, MAP_CALL(FileIOExists), "r", NULL }, 327 { SIG_SINCE_SCI11, 11, MAP_CALL(FileIORename), "rr", NULL }, 328 { SIG_SINCE_SCI11, 12, MAP_CALL(FileIOCopy), "rr", NULL }, 329 #ifdef ENABLE_SCI32 330 { SIG_SINCE_SCI21MID, 13, MAP_CALL(FileIOReadByte), "i", NULL }, 331 { SIG_SINCE_SCI21MID, 14, MAP_CALL(FileIOWriteByte), "ii", NULL }, 332 { SIG_SINCE_SCI21MID, 15, MAP_CALL(FileIOReadWord), "i", NULL }, 333 { SIG_SCI21MID, 16, MAP_CALL(FileIOWriteWord), "ii", NULL }, 334 { SIG_SINCE_SCI21LATE,16, MAP_CALL(FileIOWriteWord), "i[.!]", NULL }, 335 { SIG_SINCE_SCI21MID, 17, "FileIOCheckFreeSpace", kCheckFreeSpace, "i(r)", kFileIOCheckFreeSpace_workarounds }, 336 { SIG_SINCE_SCI21MID, 18, MAP_CALL(FileIOGetCWD), "r", NULL }, 337 { SIG_SINCE_SCI21MID, 19, MAP_CALL(FileIOIsValidDirectory), "[ro]", NULL }, 338 #endif 339 SCI_SUBOPENTRY_TERMINATOR 340 }; 341 342 #ifdef ENABLE_SCI32 343 344 // version, subId, function-mapping, signature, workarounds 345 static const SciKernelMapSubEntry kPalCycle_subops[] = { 346 { SIG_SCI32, 0, MAP_CALL(PalCycleSetCycle), "iii(i)", NULL }, 347 { SIG_SCI32, 1, MAP_CALL(PalCycleDoCycle), "i(i)", NULL }, 348 { SIG_SCI32, 2, MAP_CALL(PalCyclePause), "(i)", NULL }, 349 { SIG_SCI32, 3, MAP_CALL(PalCycleOn), "(i)", NULL }, 350 { SIG_SCI32, 4, MAP_CALL(PalCycleOff), "(i)", NULL }, 351 SCI_SUBOPENTRY_TERMINATOR 352 }; 353 354 // version, subId, function-mapping, signature, workarounds 355 static const SciKernelMapSubEntry kSave_subops[] = { 356 { SIG_SCI32, 0, MAP_CALL(SaveGame32), "[r0]i[r0][r0]", NULL }, 357 { SIG_SCI32, 1, MAP_CALL(RestoreGame32), "[r0]i[r0]", NULL }, 358 // System script 64994 in several SCI2.1mid games (KQ7 2.00b, Phant1, 359 // PQ:SWAT, SQ6, Torin) calls GetSaveDir with an extra unused argument, and 360 // it is easier to just handle it here than to bother with creating 361 // workarounds 362 { SIG_SCI32, 2, MAP_CALL(GetSaveDir), "(r)", NULL }, 363 { SIG_SCI32, 3, MAP_CALL(CheckSaveGame32), "ri[r0]", NULL }, 364 // Subop 4 hasn't been encountered yet 365 { SIG_SCI32, 5, MAP_CALL(GetSaveFiles32), "rrr", NULL }, 366 { SIG_SCI32, 6, MAP_CALL(MakeSaveCatName), "rr", NULL }, 367 { SIG_SCI32, 7, MAP_CALL(MakeSaveFileName), "rri", NULL }, 368 { SIG_SCI32, 8, MAP_EMPTY(GameIsRestarting), "(.*)", NULL }, 369 SCI_SUBOPENTRY_TERMINATOR 370 }; 371 372 // version, subId, function-mapping, signature, workarounds 373 static const SciKernelMapSubEntry kFont_subops[] = { 374 { SIG_SINCE_SCI21MID, 0, MAP_CALL(PointSize), "i", NULL }, 375 { SIG_SINCE_SCI21MID, 1, MAP_CALL(SetFontRes), "ii", NULL }, 376 SCI_SUBOPENTRY_TERMINATOR 377 }; 378 379 // version, subId, function-mapping, signature, workarounds 380 static const SciKernelMapSubEntry kText_subops[] = { 381 { SIG_SINCE_SCI21MID, 0, MAP_CALL(TextSize32), "r[r0]i(i)(i)", NULL }, 382 { SIG_SINCE_SCI21MID, 1, MAP_CALL(TextWidth), "ri", NULL }, 383 SCI_SUBOPENTRY_TERMINATOR 384 }; 385 386 // version, subId, function-mapping, signature, workarounds 387 static const SciKernelMapSubEntry kBitmap_subops[] = { 388 { SIG_SINCE_SCI21, 0, MAP_CALL(BitmapCreate), "iiii(i)(i)(i)", NULL }, 389 { SIG_SINCE_SCI21, 1, MAP_CALL(BitmapDestroy), "[r!]", NULL }, 390 { SIG_SINCE_SCI21, 2, MAP_DUMMY(BitmapDrawLine), "riiiii(i)(i)", NULL }, 391 { SIG_SINCE_SCI21, 3, MAP_CALL(BitmapDrawView), "riii(i)(i)(0)(i)(i)", NULL }, 392 { SIG_SINCE_SCI21, 4, MAP_CALL(BitmapDrawText), "rriiiiiiiiiii", NULL }, 393 { SIG_SINCE_SCI21, 5, MAP_CALL(BitmapDrawColor), "riiiii", NULL }, 394 { SIG_SINCE_SCI21, 6, MAP_DUMMY(BitmapDrawBitmap), "rr(i)(i)(i)", NULL }, 395 { SIG_SINCE_SCI21, 7, MAP_DUMMY(BitmapInvert), "riiiiii", NULL }, 396 { SIG_SINCE_SCI21MID, 8, MAP_CALL(BitmapSetOrigin), "rii", NULL }, 397 { SIG_SINCE_SCI21MID, 9, MAP_CALL(BitmapCreateFromView), "iii(i)(i)(i)([r0])", NULL }, 398 { SIG_SINCE_SCI21MID, 10, MAP_DUMMY(BitmapCopyPixels), "rr", NULL }, 399 { SIG_SINCE_SCI21MID, 11, MAP_DUMMY(BitmapClone), "r", NULL }, 400 { SIG_SINCE_SCI21MID, 12, MAP_CALL(BitmapGetInfo), "r(i)(i)", NULL }, 401 { SIG_SINCE_SCI21LATE,13, MAP_DUMMY(BitmapScale), "r...ii", NULL }, 402 { SIG_SINCE_SCI21LATE,14, MAP_DUMMY(BitmapCreateFromUnknown), "......", NULL }, 403 { SIG_SCI3, 15, MAP_DUMMY(Bitmap), "(.*)", NULL }, 404 { SIG_SCI3, 16, MAP_DUMMY(Bitmap), "(.*)", NULL }, 405 SCI_SUBOPENTRY_TERMINATOR 406 }; 407 408 // version, subId, function-mapping, signature, workarounds 409 static const SciKernelMapSubEntry kCD_subops[] = { 410 { SIG_SINCE_SCI21MID, 0, MAP_CALL(CheckCD), "(i)(i)", NULL }, 411 { SIG_SINCE_SCI21MID, 1, MAP_CALL(GetSavedCD), "", NULL }, 412 SCI_SUBOPENTRY_TERMINATOR 413 }; 414 415 // version, subId, function-mapping, signature, workarounds 416 static const SciKernelMapSubEntry kList_subops[] = { 417 { SIG_SINCE_SCI21, 0, MAP_CALL(NewList), "", NULL }, 418 { SIG_SINCE_SCI21, 1, MAP_CALL(DisposeList), "l", NULL }, 419 { SIG_SINCE_SCI21, 2, MAP_CALL(NewNode), ".(.)", NULL }, 420 { SIG_SINCE_SCI21, 3, MAP_CALL(FirstNode), "[l0]", NULL }, 421 { SIG_SINCE_SCI21, 4, MAP_CALL(LastNode), "l", NULL }, 422 { SIG_SINCE_SCI21, 5, MAP_CALL(EmptyList), "l", NULL }, 423 { SIG_SINCE_SCI21, 6, MAP_CALL(NextNode), "n", NULL }, 424 { SIG_SINCE_SCI21, 7, MAP_CALL(PrevNode), "n", NULL }, 425 { SIG_SINCE_SCI21, 8, MAP_CALL(NodeValue), "[n0]", NULL }, 426 { SIG_SINCE_SCI21, 9, MAP_CALL(AddAfter), "lnn(.)", NULL }, 427 { SIG_SINCE_SCI21, 10, MAP_CALL(AddToFront), "ln(.)", NULL }, 428 { SIG_SINCE_SCI21, 11, MAP_CALL(AddToEnd), "ln(.)", NULL }, 429 { SIG_SINCE_SCI21, 12, MAP_CALL(AddBefore), "ln.", NULL }, 430 { SIG_SINCE_SCI21, 13, MAP_CALL(MoveToFront), "ln", NULL }, 431 { SIG_SINCE_SCI21, 14, MAP_CALL(MoveToEnd), "ln", NULL }, 432 { SIG_SINCE_SCI21, 15, MAP_CALL(FindKey), "l.", NULL }, 433 { SIG_SINCE_SCI21, 16, MAP_CALL(DeleteKey), "l.", NULL }, 434 { SIG_SINCE_SCI21, 17, MAP_CALL(ListAt), "li", kListAt_workarounds }, 435 { SIG_SINCE_SCI21, 18, MAP_CALL(ListIndexOf) , "l[io]", NULL }, 436 { SIG_SINCE_SCI21, 19, MAP_CALL(ListEachElementDo), "li(.*)", NULL }, 437 { SIG_SINCE_SCI21, 20, MAP_CALL(ListFirstTrue), "li(.*)", NULL }, 438 { SIG_SINCE_SCI21, 21, MAP_CALL(ListAllTrue), "li(.*)", NULL }, 439 { SIG_SINCE_SCI21, 22, MAP_CALL(ListSort), "li(i)", NULL }, 440 SCI_SUBOPENTRY_TERMINATOR 441 }; 442 443 // version, subId, function-mapping, signature, workarounds 444 static const SciKernelMapSubEntry kShowMovieWin_subops[] = { 445 { SIG_SCI2, 0, MAP_CALL(ShowMovieWinOpen), "r", NULL }, 446 { SIG_SCI2, 1, MAP_CALL(ShowMovieWinInit), "ii(ii)", NULL }, 447 { SIG_SCI2, 2, MAP_CALL(ShowMovieWinPlay), "i", NULL }, 448 { SIG_SCI2, 6, MAP_CALL(ShowMovieWinClose), "", NULL }, 449 { SIG_SINCE_SCI21, 0, MAP_CALL(ShowMovieWinOpen), "ir", NULL }, 450 { SIG_SINCE_SCI21, 1, MAP_CALL(ShowMovieWinInit), "iii(ii)", NULL }, 451 { SIG_SINCE_SCI21, 2, MAP_CALL(ShowMovieWinPlay), "i(ii)(i)(i)", NULL }, 452 { SIG_SINCE_SCI21, 6, MAP_CALL(ShowMovieWinClose), "i", NULL }, 453 // Since movies are rendered within the graphics engine in ScummVM, 454 // it is not necessary to copy the palette from SCI to MCI, so this 455 // can be a no-op 456 { SIG_SINCE_SCI21, 7, MAP_EMPTY(ShowMovieWinSetPalette), "i", NULL }, 457 { SIG_SINCE_SCI21, 8, MAP_CALL(ShowMovieWinGetDuration), "i", NULL }, 458 { SIG_SINCE_SCI21, 11, MAP_CALL(ShowMovieWinCue), "ii", NULL }, 459 { SIG_SINCE_SCI21, 14, MAP_CALL(ShowMovieWinPlayUntilEvent), "i(i)", NULL }, 460 { SIG_SINCE_SCI21, 15, MAP_CALL(ShowMovieWinInitDouble), "iii", NULL }, 461 SCI_SUBOPENTRY_TERMINATOR 462 }; 463 464 // There are a lot of subops to PlayVMD, but only a few of them are ever 465 // actually used by games 466 // version, subId, function-mapping, signature, workarounds 467 static const SciKernelMapSubEntry kPlayVMD_subops[] = { 468 { SIG_SINCE_SCI21, 0, MAP_CALL(PlayVMDOpen), "r(i)(i)", NULL }, 469 { SIG_SINCE_SCI21, 1, MAP_CALL(PlayVMDInit), "ii(i)(i)(ii)", NULL }, 470 { SIG_SINCE_SCI21, 6, MAP_CALL(PlayVMDClose), "", NULL }, 471 { SIG_SINCE_SCI21, 7, MAP_CALL(PlayVMDIgnorePalettes), "", NULL }, 472 { SIG_SINCE_SCI21, 10, MAP_CALL(PlayVMDGetStatus), "", NULL }, 473 { SIG_SINCE_SCI21, 14, MAP_CALL(PlayVMDPlayUntilEvent), "i(i)(i)", NULL }, 474 { SIG_SINCE_SCI21, 16, MAP_CALL(PlayVMDShowCursor), "i", NULL }, 475 { SIG_SINCE_SCI21, 17, MAP_CALL(PlayVMDStartBlob), "", NULL }, 476 { SIG_SINCE_SCI21, 18, MAP_CALL(PlayVMDStopBlobs), "", NULL }, 477 { SIG_SINCE_SCI21, 19, MAP_CALL(PlayVMDAddBlob), "iiiii", NULL }, 478 { SIG_SINCE_SCI21, 20, MAP_CALL(PlayVMDDeleteBlob), "i", NULL }, 479 { SIG_SINCE_SCI21, 21, MAP_CALL(PlayVMDSetBlackoutArea), "iiii", NULL }, 480 { SIG_SINCE_SCI21, 23, MAP_CALL(PlayVMDRestrictPalette), "ii", NULL }, 481 { SIG_SINCE_SCI21LATE,27, MAP_CALL(PlayVMDSetPlane), "i(i)", NULL }, 482 { SIG_SINCE_SCI21LATE,28, MAP_EMPTY(PlayVMDSetPreload), "i", NULL }, 483 { SIG_SINCE_SCI21LATE,31, MAP_EMPTY(PlayVMDSetFrameRate), "i", NULL }, 484 SCI_SUBOPENTRY_TERMINATOR 485 }; 486 487 // version, subId, function-mapping, signature, workarounds 488 static const SciKernelMapSubEntry kRobot_subops[] = { 489 { SIG_SINCE_SCI21, 0, MAP_CALL(RobotOpen), "ioiii(i)", NULL }, 490 { SIG_SINCE_SCI21, 1, MAP_CALL(RobotShowFrame), "i(ii)", NULL }, 491 { SIG_SINCE_SCI21, 2, MAP_CALL(RobotGetFrameSize), "r", NULL }, 492 { SIG_SINCE_SCI21, 4, MAP_CALL(RobotPlay), "", NULL }, 493 { SIG_SINCE_SCI21, 5, MAP_CALL(RobotGetIsFinished), "", NULL }, 494 { SIG_SINCE_SCI21, 6, MAP_CALL(RobotGetIsInitialized), "", NULL }, 495 { SIG_SINCE_SCI21, 7, MAP_CALL(RobotClose), "", NULL }, 496 { SIG_SINCE_SCI21, 8, MAP_CALL(RobotGetCue), "o", NULL }, 497 { SIG_SINCE_SCI21, 10, MAP_CALL(RobotPause), "", NULL }, 498 { SIG_SINCE_SCI21, 11, MAP_CALL(RobotGetFrameNo), "", NULL }, 499 { SIG_SINCE_SCI21, 12, MAP_CALL(RobotSetPriority), "i", NULL }, 500 SCI_SUBOPENTRY_TERMINATOR 501 }; 502 503 // version, subId, function-mapping, signature, workarounds 504 static const SciKernelMapSubEntry kPlayDuck_subops[] = { 505 { SIG_SCI3, 1, MAP_CALL(PlayDuckPlay), "iiiii", NULL }, 506 { SIG_SCI3, 2, MAP_CALL(PlayDuckSetFrameOut), "i", NULL }, 507 { SIG_SCI3, 5, MAP_CALL(PlayDuckClose), "", NULL }, 508 { SIG_SCI3, 6, MAP_CALL(PlayDuckSetVolume), "i", NULL }, 509 SCI_SUBOPENTRY_TERMINATOR 510 }; 511 512 // version, subId, function-mapping, signature, workarounds 513 static const SciKernelMapSubEntry kRemapColors_subops[] = { 514 { SIG_SCI32, 0, MAP_CALL(RemapColorsOff), "(i)", NULL }, 515 { SIG_SCI32, 1, MAP_CALL(RemapColorsByRange), "iiii(i)", NULL }, 516 { SIG_SCI32, 2, MAP_CALL(RemapColorsByPercent), "ii(i)", NULL }, 517 { SIG_SCI32, 3, MAP_CALL(RemapColorsToGray), "ii(i)", NULL }, 518 { SIG_SCI32, 4, MAP_CALL(RemapColorsToPercentGray), "iii(i)", NULL }, 519 { SIG_SCI32, 5, MAP_CALL(RemapColorsBlockRange), "ii", NULL }, 520 SCI_SUBOPENTRY_TERMINATOR 521 }; 522 523 // version, subId, function-mapping, signature, workarounds 524 static const SciKernelMapSubEntry kArray_subops[] = { 525 { SIG_SCI32, 0, MAP_CALL(ArrayNew), "ii", NULL }, 526 { SIG_SCI32, 1, MAP_CALL(ArrayGetSize), "r", NULL }, 527 { SIG_SCI32, 2, MAP_CALL(ArrayGetElement), "ri", NULL }, 528 { SIG_SCI32, 3, MAP_CALL(ArraySetElements), "ri(.*)", kArraySetElements_workarounds }, 529 { SIG_SCI32, 4, MAP_CALL(ArrayFree), "[r0]", NULL }, 530 { SIG_SCI32, 5, MAP_CALL(ArrayFill), "riii", kArrayFill_workarounds }, 531 { SIG_SCI32, 6, MAP_CALL(ArrayCopy), "ririi", NULL }, 532 // there is no subop 7 533 { SIG_SCI32, 8, MAP_CALL(ArrayDuplicate), "r", NULL }, 534 { SIG_SCI32, 9, MAP_CALL(ArrayGetData), "[or0]", NULL }, 535 { SIG_SCI3, 10, MAP_CALL(ArrayByteCopy), "ririi", NULL }, 536 SCI_SUBOPENTRY_TERMINATOR 537 }; 538 539 // version, subId, function-mapping, signature, workarounds 540 static const SciKernelMapSubEntry kString_subops[] = { 541 // every single copy of script 64918 in SCI2 through 2.1mid calls StringNew 542 // with a second type argument which is unused (new strings are always type 543 // 3) 544 { SIG_THRU_SCI21MID, 0, MAP_CALL(StringNew), "i(i)", NULL }, 545 { SIG_THRU_SCI21MID, 1, MAP_CALL(ArrayGetSize), "r", NULL }, 546 { SIG_THRU_SCI21MID, 2, MAP_CALL(StringGetChar), "[r0]i", NULL }, 547 { SIG_THRU_SCI21MID, 3, MAP_CALL(ArraySetElements), "ri(i*)", kArraySetElements_workarounds }, 548 { SIG_THRU_SCI21MID, 4, MAP_CALL(StringFree), "[r0]", NULL }, 549 { SIG_THRU_SCI21MID, 5, MAP_CALL(ArrayFill), "riii", kArrayFill_workarounds }, 550 { SIG_THRU_SCI21MID, 6, MAP_CALL(ArrayCopy), "ririi", NULL }, 551 { SIG_SCI32, 7, MAP_CALL(StringCompare), "[r0][r0](i)", NULL }, 552 553 { SIG_THRU_SCI21MID, 8, MAP_CALL(ArrayDuplicate), "r", NULL }, 554 { SIG_THRU_SCI21MID, 9, MAP_CALL(ArrayGetData), "[or0]", NULL }, 555 { SIG_THRU_SCI21MID, 10, MAP_CALL(StringLength), "[r0]", NULL }, 556 { SIG_THRU_SCI21MID, 11, MAP_CALL(StringFormat), "[or0](.*)", NULL }, 557 { SIG_THRU_SCI21MID, 12, MAP_CALL(StringFormatAt), "r[or0](.*)", NULL }, 558 { SIG_THRU_SCI21MID, 13, MAP_CALL(StringToInteger), "[r0]", NULL }, 559 { SIG_THRU_SCI21MID, 14, MAP_CALL(StringTrim), "[r0]i(i)", NULL }, 560 { SIG_THRU_SCI21MID, 15, MAP_CALL(StringToUpperCase), "[r0]", NULL }, 561 { SIG_THRU_SCI21MID, 16, MAP_CALL(StringToLowerCase), "[r0]", NULL }, 562 { SIG_THRU_SCI21MID, 17, MAP_CALL(StringReplaceSubstring), "[r0][r0][r0][r0]", NULL }, 563 { SIG_THRU_SCI21MID, 18, MAP_CALL(StringReplaceSubstringEx), "[r0][r0][r0][r0]", NULL }, 564 565 { SIG_SINCE_SCI21LATE, 8, MAP_CALL(StringLength), "[r0]", NULL }, 566 { SIG_SINCE_SCI21LATE, 9, MAP_CALL(StringFormat), "[or0](.*)", NULL }, 567 { SIG_SINCE_SCI21LATE,10, MAP_CALL(StringFormatAt), "[r0][or0](.*)", NULL }, 568 { SIG_SINCE_SCI21LATE,11, MAP_CALL(StringToInteger), "[r0]", NULL }, 569 { SIG_SINCE_SCI21LATE,12, MAP_CALL(StringTrim), "[r0]i(i)", NULL }, 570 { SIG_SINCE_SCI21LATE,13, MAP_CALL(StringToUpperCase), "[r0]", NULL }, 571 { SIG_SINCE_SCI21LATE,14, MAP_CALL(StringToLowerCase), "[r0]", NULL }, 572 { SIG_SINCE_SCI21LATE,15, MAP_CALL(StringReplaceSubstring), "[r0][r0][r0][r0]", NULL }, 573 { SIG_SINCE_SCI21LATE,16, MAP_CALL(StringReplaceSubstringEx), "[r0][r0][r0][r0]", NULL }, 574 SCI_SUBOPENTRY_TERMINATOR 575 }; 576 577 // version, subId, function-mapping, signature, workarounds 578 static const SciKernelMapSubEntry kCelInfo_subops[] = { 579 { SIG_SINCE_SCI21MID, 0, MAP_CALL(CelInfoGetOriginX), "iii", NULL }, 580 { SIG_SINCE_SCI21MID, 1, MAP_CALL(CelInfoGetOriginY), "iii", NULL }, 581 { SIG_SINCE_SCI21MID, 2, MAP_EMPTY(CelInfo), "iii", NULL }, 582 { SIG_SINCE_SCI21MID, 3, MAP_EMPTY(CelInfo), "iii", NULL }, 583 { SIG_SINCE_SCI21MID, 4, MAP_CALL(CelInfoGetPixel), "iiiii", NULL }, 584 SCI_SUBOPENTRY_TERMINATOR 585 }; 586 587 // version, subId, function-mapping, signature, workarounds 588 static const SciKernelMapSubEntry kCelLink_subops[] = { 589 { SIG_SINCE_SCI21MID, 0, MAP_DUMMY(CelLink0), "", NULL }, 590 { SIG_SINCE_SCI21MID, 1, MAP_DUMMY(CelLink1), "", NULL }, 591 { SIG_SINCE_SCI21MID, 2, MAP_CALL(CelLinkGetX), "iiii", NULL }, 592 { SIG_SINCE_SCI21MID, 3, MAP_CALL(CelLinkGetY), "iiii", NULL }, 593 { SIG_SINCE_SCI21MID, 4, MAP_DUMMY(CelLink4), "", NULL }, 594 SCI_SUBOPENTRY_TERMINATOR 595 }; 596 597 // version, subId, function-mapping, signature, workarounds 598 static const SciKernelMapSubEntry kScrollWindow_subops[] = { 599 { SIG_SCI32, 0, MAP_CALL(ScrollWindowCreate), "oi", NULL }, 600 { SIG_SCI32, 1, MAP_CALL(ScrollWindowAdd), "iriii(i)", kScrollWindowAdd_workarounds }, 601 { SIG_SCI32, 2, MAP_DUMMY(ScrollWindowClear), "i", NULL }, 602 { SIG_SCI32, 3, MAP_CALL(ScrollWindowPageUp), "i", NULL }, 603 { SIG_SCI32, 4, MAP_CALL(ScrollWindowPageDown), "i", NULL }, 604 { SIG_SCI32, 5, MAP_CALL(ScrollWindowUpArrow), "i", NULL }, 605 { SIG_SCI32, 6, MAP_CALL(ScrollWindowDownArrow), "i", NULL }, 606 { SIG_SCI32, 7, MAP_CALL(ScrollWindowHome), "i", NULL }, 607 { SIG_SCI32, 8, MAP_CALL(ScrollWindowEnd), "i", NULL }, 608 { SIG_SCI32, 9, MAP_DUMMY(ScrollWindowResize), "i.", NULL }, 609 { SIG_SCI32, 10, MAP_CALL(ScrollWindowWhere), "ii", NULL }, 610 { SIG_SCI32, 11, MAP_CALL(ScrollWindowGo), "i..", NULL }, 611 { SIG_SCI32, 12, MAP_DUMMY(ScrollWindowInsert), "i.....", NULL }, 612 { SIG_SCI32, 13, MAP_DUMMY(ScrollWindowDelete), "i.", NULL }, 613 { SIG_SCI32, 14, MAP_CALL(ScrollWindowModify), "iiriii(i)", NULL }, 614 { SIG_SCI32, 15, MAP_CALL(ScrollWindowHide), "i", NULL }, 615 { SIG_SCI32, 16, MAP_CALL(ScrollWindowShow), "i", NULL }, 616 { SIG_SCI32, 17, MAP_CALL(ScrollWindowDestroy), "i", NULL }, 617 // LSL6hires uses kScrollWindowText and kScrollWindowReconstruct to try to save 618 // and restore the content of the game's subtitle window, but this feature did not 619 // use the normal save/load functionality of the engine and was actually broken 620 // (all text formatting was missing on restore). Since there is no real reason to 621 // save the subtitle scrollback anyway, we just ignore calls to these two functions. 622 { SIG_SCI32, 18, MAP_EMPTY(ScrollWindowText), "i", NULL }, 623 { SIG_SCI32, 19, MAP_EMPTY(ScrollWindowReconstruct), "i.", NULL }, 624 SCI_SUBOPENTRY_TERMINATOR 625 }; 626 627 #endif 628 629 struct SciKernelMapEntry { 630 const char *name; 631 KernelFunctionCall *function; 632 633 SciVersion fromVersion; 634 SciVersion toVersion; 635 byte forPlatform; 636 637 const char *signature; 638 const SciKernelMapSubEntry *subFunctions; 639 const SciWorkaroundEntry *workarounds; 640 }; 641 642 // name, version/platform, signature, sub-signatures, workarounds 643 static SciKernelMapEntry s_kernelMap[] = { 644 { MAP_CALL(Abs), SIG_EVERYWHERE, "i", NULL, kAbs_workarounds }, 645 { MAP_CALL(AddAfter), SIG_EVERYWHERE, "lnn", NULL, NULL }, 646 { MAP_CALL(AddMenu), SIG_EVERYWHERE, "rr", NULL, NULL }, 647 { MAP_CALL(AddToEnd), SIG_EVERYWHERE, "ln", NULL, NULL }, 648 { MAP_CALL(AddToFront), SIG_EVERYWHERE, "ln", NULL, NULL }, 649 { MAP_CALL(AddToPic), SIG_EVERYWHERE, "[il](iiiiii)", NULL, NULL }, 650 { MAP_CALL(Animate), SIG_EVERYWHERE, "(l0)(i)", NULL, NULL }, 651 { MAP_CALL(AssertPalette), SIG_EVERYWHERE, "i", NULL, NULL }, 652 { MAP_CALL(AvoidPath), SIG_EVERYWHERE, "ii(.*)", NULL, NULL }, 653 { MAP_CALL(BaseSetter), SIG_SCI16, SIGFOR_ALL, "o", NULL, NULL }, 654 #ifdef ENABLE_SCI32 655 { "BaseSetter", kBaseSetter32, SIG_SCI32, SIGFOR_ALL, "o", NULL, NULL }, 656 #endif 657 { MAP_CALL(CanBeHere), SIG_EVERYWHERE, "o(l)", NULL, NULL }, 658 { MAP_CALL(CantBeHere), SIG_SCI16, SIGFOR_ALL, "o(l)", NULL, NULL }, 659 #ifdef ENABLE_SCI32 660 { MAP_CALL(CantBeHere), SIG_SCI32, SIGFOR_ALL, "ol", NULL, NULL }, 661 #endif 662 { MAP_CALL(CelHigh), SIG_SCI16, SIGFOR_ALL, "ii(i)", NULL, kCelHigh_workarounds }, 663 { MAP_CALL(CelWide), SIG_SCI16, SIGFOR_ALL, "ii(i)", NULL, kCelWide_workarounds }, 664 #ifdef ENABLE_SCI32 665 { "CelHigh", kCelHigh32, SIG_SCI32, SIGFOR_ALL, "iii", NULL, NULL }, 666 { "CelWide", kCelWide32, SIG_SCI32, SIGFOR_ALL, "iii", NULL, kCelWide_workarounds }, 667 #endif 668 { MAP_CALL(CheckFreeSpace), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "r(i)", NULL, NULL }, 669 { MAP_CALL(CheckFreeSpace), SIG_SCI11, SIGFOR_ALL, "r(i)", NULL, NULL }, 670 { MAP_CALL(CheckFreeSpace), SIG_SCI16, SIGFOR_ALL, "r", NULL, NULL }, 671 #ifdef ENABLE_SCI32 672 { "CheckSaveGame", kCheckSaveGame32, SIG_THRU_SCI21EARLY, SIGFOR_ALL, "ri[r0]", NULL, NULL }, 673 #endif 674 { MAP_CALL(CheckSaveGame), SIG_SCI16, SIGFOR_ALL, ".*", NULL, NULL }, 675 { MAP_CALL(Clone), SIG_EVERYWHERE, "o", NULL, NULL }, 676 { MAP_CALL(CoordPri), SIG_EVERYWHERE, "i(i)", NULL, NULL }, 677 { MAP_CALL(CosDiv), SIG_EVERYWHERE, "ii", NULL, NULL }, 678 { MAP_CALL(DeleteKey), SIG_EVERYWHERE, "l.", NULL, kDeleteKey_workarounds }, 679 { MAP_CALL(DeviceInfo), SIG_EVERYWHERE, "i(r)(r)(i)", NULL, kDeviceInfo_workarounds }, // subop 680 { MAP_CALL(Display), SIG_EVERYWHERE, "[ir]([ir!]*)", NULL, kDisplay_workarounds }, 681 // ^ we allow invalid references here, because kDisplay gets called with those in e.g. pq3 during intro 682 // restoreBits() checks and skips invalid handles, so that's fine. Sierra SCI behaved the same 683 { MAP_CALL(DirLoop), SIG_EVERYWHERE, "oi", NULL, kDirLoop_workarounds }, 684 { MAP_CALL(DisposeClone), SIG_EVERYWHERE, "o", NULL, NULL }, 685 { MAP_CALL(DisposeList), SIG_EVERYWHERE, "l", NULL, NULL }, 686 { MAP_CALL(DisposeScript), SIG_EVERYWHERE, "i(i*)", NULL, kDisposeScript_workarounds }, 687 { MAP_CALL(DisposeWindow), SIG_EVERYWHERE, "i(i)", NULL, NULL }, 688 { MAP_CALL(DoAudio), SIG_SCI16, SIGFOR_ALL, "i(.*)", NULL, NULL }, // subop 689 #ifdef ENABLE_SCI32 690 { "DoAudio", kDoAudio32, SIG_SCI32, SIGFOR_ALL, "(.*)", kDoAudio_subops, NULL }, 691 #endif 692 { MAP_CALL(DoAvoider), SIG_EVERYWHERE, "o(i)", NULL, NULL }, 693 { MAP_CALL(DoBresen), SIG_EVERYWHERE, "o", NULL, NULL }, 694 { MAP_CALL(DoSound), SIG_EVERYWHERE, "i(.*)", kDoSound_subops, NULL }, 695 { MAP_CALL(DoSync), SIG_EVERYWHERE, "i(.*)", NULL, NULL }, // subop 696 { MAP_CALL(DrawCel), SIG_SCI11, SIGFOR_PC, "iiiii(i)(i)([ri])", NULL, NULL }, // reference for kq6 hires 697 { MAP_CALL(DrawCel), SIG_EVERYWHERE, "iiiii(i)(i)", NULL, NULL }, 698 { MAP_CALL(DrawControl), SIG_EVERYWHERE, "o", NULL, NULL }, 699 { MAP_CALL(DrawMenuBar), SIG_EVERYWHERE, "i", NULL, NULL }, 700 { MAP_CALL(DrawPic), SIG_EVERYWHERE, "i(i)(i)(i)", NULL, NULL }, 701 { MAP_CALL(DrawStatus), SIG_EVERYWHERE, "[r0](i)(i)", NULL, NULL }, 702 { MAP_CALL(EditControl), SIG_EVERYWHERE, "[o0][o0]", NULL, NULL }, 703 { MAP_CALL(Empty), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 704 { MAP_CALL(EmptyList), SIG_EVERYWHERE, "l", NULL, NULL }, 705 { "FClose", kFileIOClose, SIG_EVERYWHERE, "i", NULL, NULL }, 706 { "FGets", kFileIOReadString, SIG_EVERYWHERE, "rii", NULL, NULL }, 707 { "FOpen", kFileIOOpen, SIG_EVERYWHERE, "ri", NULL, NULL }, 708 { "FPuts", kFileIOWriteString, SIG_EVERYWHERE, "ir", NULL, NULL }, 709 { MAP_CALL(FileIO), SIG_EVERYWHERE, "i([.!]*)", kFileIO_subops, NULL }, 710 { MAP_CALL(FindKey), SIG_EVERYWHERE, "l.", NULL, kFindKey_workarounds }, 711 { MAP_CALL(FirstNode), SIG_EVERYWHERE, "[l0]", NULL, NULL }, 712 { MAP_CALL(FlushResources), SIG_EVERYWHERE, "i", NULL, NULL }, 713 { MAP_CALL(Format), SIG_EVERYWHERE, "r[ri](.*)", NULL, NULL }, 714 { MAP_CALL(GameIsRestarting), SIG_EVERYWHERE, "(i)", NULL, NULL }, 715 { MAP_CALL(GetAngle), SIG_EVERYWHERE, "iiii", NULL, kGetAngle_workarounds }, 716 { MAP_CALL(GetCWD), SIG_EVERYWHERE, "r", NULL, kGetCWD_workarounds }, 717 { MAP_CALL(GetDistance), SIG_EVERYWHERE, "ii(i)(i)(i)(i)", NULL, NULL }, 718 { MAP_CALL(GetEvent), SIG_SCIALL, SIGFOR_MAC, "io(i*)", NULL, NULL }, 719 { MAP_CALL(GetEvent), SIG_EVERYWHERE, "io", NULL, NULL }, 720 { MAP_CALL(GetFarText), SIG_EVERYWHERE, "ii[r0]", NULL, NULL }, 721 { MAP_CALL(GetMenu), SIG_EVERYWHERE, "i.", NULL, NULL }, 722 { MAP_CALL(GetMessage), SIG_EVERYWHERE, "iiir", NULL, NULL }, 723 { MAP_CALL(GetPort), SIG_EVERYWHERE, "", NULL, NULL }, 724 #ifdef ENABLE_SCI32 725 { MAP_CALL(GetSaveDir), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "(r)", NULL, NULL }, 726 #endif 727 { MAP_CALL(GetSaveDir), SIG_SCI16, SIGFOR_ALL, "", NULL, NULL }, 728 #ifdef ENABLE_SCI32 729 { "GetSaveFiles", kGetSaveFiles32, SIG_THRU_SCI21EARLY, SIGFOR_ALL, "rrr", NULL, NULL }, 730 #endif 731 { MAP_CALL(GetSaveFiles), SIG_EVERYWHERE, "rrr", NULL, NULL }, 732 { MAP_CALL(GetTime), SIG_EVERYWHERE, "(i)", NULL, NULL }, 733 { MAP_CALL(GlobalToLocal), SIG_SCI16, SIGFOR_ALL, "o", NULL, NULL }, 734 #ifdef ENABLE_SCI32 735 { "GlobalToLocal", kGlobalToLocal32, SIG_SCI32, SIGFOR_ALL, "oo", NULL, NULL }, 736 #endif 737 { MAP_CALL(Graph), SIG_SCI16, SIGFOR_ALL, NULL, kGraph_subops, NULL }, 738 #ifdef ENABLE_SCI32 739 { MAP_EMPTY(Graph), SIG_SCI32, SIGFOR_ALL, "(.*)", NULL, NULL }, 740 #endif 741 { MAP_CALL(HaveMouse), SIG_EVERYWHERE, "", NULL, NULL }, 742 { MAP_CALL(HiliteControl), SIG_EVERYWHERE, "o", NULL, NULL }, 743 { MAP_CALL(InitBresen), SIG_EVERYWHERE, "o(i)", NULL, NULL }, 744 { MAP_CALL(Intersections), SIG_EVERYWHERE, "iiiiriiiri", NULL, NULL }, 745 { MAP_CALL(IsItSkip), SIG_EVERYWHERE, "iiiii", NULL, NULL }, 746 { MAP_CALL(IsObject), SIG_EVERYWHERE, ".", NULL, kIsObject_workarounds }, 747 { MAP_CALL(Joystick), SIG_EVERYWHERE, "i(.*)", NULL, NULL }, // subop 748 { MAP_CALL(LastNode), SIG_EVERYWHERE, "l", NULL, NULL }, 749 { MAP_CALL(Load), SIG_EVERYWHERE, "ii(i*)", NULL, NULL }, 750 { MAP_CALL(LocalToGlobal), SIG_SCI16, SIGFOR_ALL, "o", NULL, NULL }, 751 #ifdef ENABLE_SCI32 752 { "LocalToGlobal", kLocalToGlobal32, SIG_SCI32, SIGFOR_ALL, "oo", NULL, NULL }, 753 #endif 754 { MAP_CALL(Lock), SIG_EVERYWHERE, "ii(i)", NULL, kLock_workarounds }, 755 { MAP_CALL(MapKeyToDir), SIG_EVERYWHERE, "o", NULL, NULL }, 756 { MAP_CALL(Memory), SIG_EVERYWHERE, "i(.*)", NULL, kMemory_workarounds }, // subop 757 { MAP_CALL(MemoryInfo), SIG_EVERYWHERE, "i", NULL, NULL }, 758 { MAP_CALL(MemorySegment), SIG_EVERYWHERE, "ir(i)", NULL, NULL }, // subop 759 { MAP_CALL(MenuSelect), SIG_EVERYWHERE, "o(i)", NULL, NULL }, 760 { MAP_CALL(MergePoly), SIG_EVERYWHERE, "rli", NULL, NULL }, 761 { MAP_CALL(Message), SIG_EVERYWHERE, "i(.*)", NULL, NULL }, // subop 762 { MAP_CALL(MoveCursor), SIG_EVERYWHERE, "ii", NULL, kMoveCursor_workarounds }, 763 { MAP_CALL(NewList), SIG_EVERYWHERE, "", NULL, NULL }, 764 { MAP_CALL(NewNode), SIG_EVERYWHERE, "..", NULL, NULL }, 765 { MAP_CALL(NewWindow), SIG_SCIALL, SIGFOR_MAC, ".*", NULL, NULL }, 766 { MAP_CALL(NewWindow), SIG_SCI0, SIGFOR_ALL, "iiii[r0]i(i)(i)(i)", NULL, NULL }, 767 { MAP_CALL(NewWindow), SIG_SCI1, SIGFOR_ALL, "iiii[ir]i(i)(i)([ir])(i)(i)(i)(i)", NULL, NULL }, 768 { MAP_CALL(NewWindow), SIG_SCI11, SIGFOR_ALL, "iiiiiiii[r0]i(i)(i)(i)", NULL, kNewWindow_workarounds }, 769 { MAP_CALL(NextNode), SIG_EVERYWHERE, "n", NULL, NULL }, 770 { MAP_CALL(NodeValue), SIG_EVERYWHERE, "[n0]", NULL, NULL }, 771 { MAP_CALL(NumCels), SIG_EVERYWHERE, "o", NULL, NULL }, 772 { MAP_CALL(NumLoops), SIG_EVERYWHERE, "o", NULL, NULL }, 773 { MAP_CALL(OnControl), SIG_EVERYWHERE, "ii(i)(i)(i)", NULL, NULL }, 774 { MAP_CALL(PalVary), SIG_EVERYWHERE, "i(i*)", kPalVary_subops, NULL }, 775 { MAP_CALL(Palette), SIG_EVERYWHERE, "i(.*)", kPalette_subops, NULL }, 776 { MAP_CALL(Parse), SIG_EVERYWHERE, "ro", NULL, NULL }, 777 { MAP_CALL(PicNotValid), SIG_EVERYWHERE, "(i)", NULL, NULL }, 778 { MAP_CALL(Platform), SIG_SCI16, SIGFOR_ALL, "(.*)", NULL, NULL }, 779 #ifdef ENABLE_SCI32 780 { "Platform", kPlatform32, SIG_SCI32, SIGFOR_MAC, "(.*)", NULL, NULL }, 781 { "Platform", kPlatform32, SIG_SCI32, SIGFOR_ALL, "(i)", NULL, kPlatform32_workarounds }, 782 #endif 783 { MAP_CALL(Portrait), SIG_EVERYWHERE, "i(.*)", NULL, NULL }, // subop 784 { MAP_CALL(PrevNode), SIG_EVERYWHERE, "n", NULL, NULL }, 785 { MAP_CALL(PriCoord), SIG_EVERYWHERE, "i", NULL, NULL }, 786 { MAP_CALL(Random), SIG_EVERYWHERE, "(i)(i)", NULL, kRandom_workarounds }, 787 { MAP_CALL(ReadNumber), SIG_EVERYWHERE, "r", NULL, kReadNumber_workarounds }, 788 { MAP_CALL(RemapColors), SIG_SCI11, SIGFOR_ALL, "i(i)(i)(i)(i)", NULL, NULL }, 789 { MAP_CALL(RemapColorsKawa), SIG_SCI11, SIGFOR_ALL, "i(i)(i)(i)(i)(i)", NULL, NULL }, 790 #ifdef ENABLE_SCI32 791 { "RemapColors", kRemapColors32, SIG_SCI32, SIGFOR_ALL, "i(i)(i)(i)(i)(i)", kRemapColors_subops, NULL }, 792 #endif 793 { MAP_CALL(ResCheck), SIG_EVERYWHERE, "ii(iiii)", NULL, kResCheck_workarounds }, 794 { MAP_CALL(RespondsTo), SIG_EVERYWHERE, ".i", NULL, NULL }, 795 { "RestartGame", kRestartGame16, SIG_SCI16, SIGFOR_ALL, "", NULL, NULL }, 796 #ifdef ENABLE_SCI32 797 { MAP_EMPTY(RestartGame), SIG_SCI32, SIGFOR_ALL, "", NULL, NULL }, 798 { "RestoreGame", kRestoreGame32, SIG_THRU_SCI21EARLY, SIGFOR_ALL, "ri[r0]", NULL, NULL }, 799 #endif 800 { MAP_CALL(RestoreGame), SIG_EVERYWHERE, "[r0]i[r0]", NULL, NULL }, 801 { MAP_CALL(Said), SIG_EVERYWHERE, "[r0]", NULL, NULL }, 802 #ifdef ENABLE_SCI32 803 { "SaveGame", kSaveGame32, SIG_THRU_SCI21EARLY, SIGFOR_ALL, "ri[r0][r0]", NULL, NULL }, 804 { MAP_CALL(ScummVMSaveLoad), SIG_SCI32, SIGFOR_ALL, "([iro])([iro])", NULL, NULL }, 805 #endif 806 { MAP_CALL(SaveGame), SIG_SCI16, SIGFOR_ALL, "[r0]i[r0](r0)", NULL, NULL }, 807 { MAP_CALL(ScriptID), SIG_EVERYWHERE, "[io](i)", NULL, NULL }, 808 { MAP_CALL(SetCursor), SIG_SCI11, SIGFOR_ALL, "i(i)(i)(i)(iiiiii)", NULL, NULL }, 809 { MAP_CALL(SetCursor), SIG_SCI16, SIGFOR_ALL, "i(i)(i)(i)(i)", NULL, kSetCursor_workarounds }, 810 #ifdef ENABLE_SCI32 811 { "SetCursor", kSetCursor32, SIG_SCI32, SIGFOR_ALL, "i(i)(i)(i)", NULL, kSetCursor_workarounds }, 812 #endif 813 { MAP_CALL(SetDebug), SIG_EVERYWHERE, "(i*)", NULL, NULL }, 814 { MAP_CALL(SetJump), SIG_EVERYWHERE, "oiii", NULL, NULL }, 815 { MAP_CALL(SetMenu), SIG_EVERYWHERE, "i(.*)", NULL, NULL }, 816 { MAP_CALL(SetNowSeen), SIG_SCI16, SIGFOR_ALL, "o(i)", NULL, NULL }, 817 #ifdef ENABLE_SCI32 818 { "SetNowSeen", kSetNowSeen32, SIG_SCI32, SIGFOR_ALL, "o", NULL, NULL }, 819 #endif 820 { MAP_CALL(SetPort), SIG_EVERYWHERE, "i(iiiii)(i)", NULL, kSetPort_workarounds }, 821 { MAP_CALL(SetQuitStr), SIG_EVERYWHERE, "r", NULL, NULL }, 822 { MAP_CALL(SetSynonyms), SIG_EVERYWHERE, "o", NULL, NULL }, 823 { MAP_CALL(SetVideoMode), SIG_EVERYWHERE, "i", NULL, NULL }, 824 { MAP_CALL(ShakeScreen), SIG_SCI16, SIGFOR_ALL, "(i)(i)", NULL, NULL }, 825 #ifdef ENABLE_SCI32 826 { "ShakeScreen", kShakeScreen32, SIG_SCI32, SIGFOR_ALL, "i(i)", NULL, NULL }, 827 #endif 828 { MAP_CALL(ShowMovie), SIG_SCI16, SIGFOR_ALL, "(.*)", NULL, NULL }, 829 #ifdef ENABLE_SCI32 830 { "ShowMovie", kShowMovie32, SIG_SCI32, SIGFOR_DOS, "ri(i)(i)", NULL, NULL }, 831 { "ShowMovie", kShowMovie32, SIG_SCI32, SIGFOR_MAC, "ri(i)(i)", NULL, NULL }, 832 { "ShowMovie", kShowMovieWin, SIG_SCI32, SIGFOR_WIN, "(.*)", kShowMovieWin_subops, NULL }, 833 #endif 834 { MAP_CALL(Show), SIG_EVERYWHERE, "i", NULL, NULL }, 835 { MAP_CALL(SinDiv), SIG_EVERYWHERE, "ii", NULL, NULL }, 836 #ifdef ENABLE_SCI32 837 { MAP_CALL(ScummVMSleep), SIG_SCI32, SIGFOR_ALL, "i", NULL, NULL }, 838 #endif 839 { MAP_CALL(Sort), SIG_EVERYWHERE, "ooo", NULL, NULL }, 840 { MAP_CALL(Sqrt), SIG_EVERYWHERE, "i", NULL, NULL }, 841 { MAP_CALL(StrAt), SIG_EVERYWHERE, "ri(i)", NULL, kStrAt_workarounds }, 842 { MAP_CALL(StrCat), SIG_EVERYWHERE, "rr", NULL, NULL }, 843 { MAP_CALL(StrCmp), SIG_EVERYWHERE, "rr(i)", NULL, NULL }, 844 { MAP_CALL(StrCpy), SIG_EVERYWHERE, "r[r0](i)", NULL, kStrCpy_workarounds }, 845 { MAP_CALL(StrEnd), SIG_EVERYWHERE, "r", NULL, NULL }, 846 { MAP_CALL(StrLen), SIG_EVERYWHERE, "[r0]", NULL, kStrLen_workarounds }, 847 { MAP_CALL(StrSplit), SIG_EVERYWHERE, "rr[r0]", NULL, NULL }, 848 { MAP_CALL(TextColors), SIG_SCI16, SIGFOR_ALL, "(i*)", NULL, NULL }, 849 { MAP_CALL(TextFonts), SIG_SCI16, SIGFOR_ALL, "(i*)", NULL, NULL }, 850 { MAP_CALL(TextSize), SIG_SCI16, SIGFOR_MAC, "r[r0]i(i)(r0)(i)", NULL, NULL }, 851 { MAP_CALL(TextSize), SIG_SCI16, SIGFOR_ALL, "r[r0]i(i)(r0)", NULL, NULL }, 852 { MAP_CALL(TimesCos), SIG_EVERYWHERE, "ii", NULL, NULL }, 853 { "CosMult", kTimesCos, SIG_EVERYWHERE, "ii", NULL, NULL }, 854 { MAP_CALL(TimesCot), SIG_EVERYWHERE, "ii", NULL, NULL }, 855 { MAP_CALL(TimesSin), SIG_EVERYWHERE, "ii", NULL, NULL }, 856 { "SinMult", kTimesSin, SIG_EVERYWHERE, "ii", NULL, NULL }, 857 { MAP_CALL(TimesTan), SIG_EVERYWHERE, "ii", NULL, NULL }, 858 { MAP_CALL(UnLoad), SIG_EVERYWHERE, "i[ir!]", NULL, kUnLoad_workarounds }, 859 // ^ We allow invalid references here (e.g. bug #6600), since they will be invalidated anyway by the call itself 860 { MAP_CALL(ValidPath), SIG_EVERYWHERE, "r", NULL, NULL }, 861 { MAP_CALL(Wait), SIG_SCI16, SIGFOR_ALL, "i", NULL, NULL }, 862 863 // Unimplemented SCI0-SCI1.1 unused functions, always mapped to kDummy 864 { MAP_DUMMY(InspectObj), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 865 { MAP_DUMMY(ShowSends), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 866 { MAP_DUMMY(ShowObjs), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 867 { MAP_DUMMY(ShowFree), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 868 { MAP_DUMMY(StackUsage), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 869 { MAP_DUMMY(Profiler), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 870 { MAP_DUMMY(ShiftScreen), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 871 { MAP_DUMMY(ListOps), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 872 // Used by the sysLogger class (e.g. script 952 in GK1CD), a class used to report bugs by Sierra's testers 873 { MAP_DUMMY(ATan), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 874 { MAP_DUMMY(Record), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 875 { MAP_DUMMY(PlayBack), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 876 { MAP_DUMMY(DbugStr), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 877 // Used in Kawa's SCI11+ 878 { MAP_CALL(KawaDbugStr), SIG_SCI11, SIGFOR_ALL, "(.*)", NULL, NULL }, 879 { MAP_CALL(KawaHacks), SIG_SCI11, SIGFOR_ALL, "(.*)", NULL, NULL }, 880 881 // ======================================================================================================= 882 883 #ifdef ENABLE_SCI32 884 // SCI2 Kernel Functions 885 // TODO: whoever knows his way through those calls, fix the signatures. 886 { "TextSize", kTextSize32, SIG_THRU_SCI21EARLY, SIGFOR_ALL, "r[r0]i(i)", NULL, NULL }, 887 { MAP_DUMMY(TextColors), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "(.*)", NULL, NULL }, 888 { MAP_DUMMY(TextFonts), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "(.*)", NULL, NULL }, 889 890 { MAP_CALL(AddPlane), SIG_EVERYWHERE, "o", NULL, NULL }, 891 { MAP_CALL(AddScreenItem), SIG_EVERYWHERE, "o", NULL, NULL }, 892 { MAP_CALL(Array), SIG_EVERYWHERE, "i(.*)", kArray_subops, NULL }, 893 { MAP_CALL(CreateTextBitmap), SIG_EVERYWHERE, "i(.*)", NULL, NULL }, 894 { MAP_CALL(DeletePlane), SIG_EVERYWHERE, "o", NULL, NULL }, 895 { MAP_CALL(DeleteScreenItem), SIG_EVERYWHERE, "o", NULL, NULL }, 896 { "DisposeTextBitmap", kBitmapDestroy, SIG_SCI2, SIGFOR_ALL, "[r!]", NULL, NULL }, 897 { MAP_CALL(FrameOut), SIG_EVERYWHERE, "(i)", NULL, kFrameOut_workarounds }, 898 { MAP_CALL(GetHighPlanePri), SIG_EVERYWHERE, "", NULL, NULL }, 899 { MAP_CALL(InPolygon), SIG_EVERYWHERE, "iio", NULL, NULL }, 900 { MAP_CALL(IsHiRes), SIG_EVERYWHERE, "", NULL, NULL }, 901 { MAP_CALL(ListAllTrue), SIG_EVERYWHERE, "li(.*)", NULL, NULL }, 902 { MAP_CALL(ListAt), SIG_EVERYWHERE, "li", NULL, NULL }, 903 { MAP_CALL(ListEachElementDo), SIG_EVERYWHERE, "li(.*)", NULL, NULL }, 904 { MAP_CALL(ListFirstTrue), SIG_EVERYWHERE, "li(.*)", NULL, NULL }, 905 { MAP_CALL(ListIndexOf), SIG_EVERYWHERE, "l[o0]", NULL, NULL }, 906 // kMessageBox is used only by KQ7 1.51 907 { MAP_CALL(MessageBox), SIG_SCI32, SIGFOR_ALL, "rri", NULL, NULL }, 908 { "OnMe", kIsOnMe, SIG_EVERYWHERE, "iioi", NULL, NULL }, 909 // Purge is used by the memory manager in SSCI to ensure that X number of bytes (the so called "unmovable 910 // memory") are available when the current room changes. This is similar to the SCI0-SCI1.1 FlushResources 911 // call, with the added functionality of ensuring that a specific amount of memory is available. We have 912 // our own memory manager and garbage collector, thus we simply call FlushResources, which in turn invokes 913 // our garbage collector (i.e. the SCI0-SCI1.1 semantics). 914 { "Purge", kFlushResources, SIG_EVERYWHERE, "i", NULL, NULL }, 915 { MAP_CALL(SetShowStyle), SIG_THRU_SCI21MID, SIGFOR_ALL, "ioiiiii([ri])(i)", NULL, NULL }, 916 { MAP_CALL(SetShowStyle), SIG_SCI21LATE, SIGFOR_PC, "ioiiiii([ri])([ri])(i)", NULL, NULL }, 917 { MAP_CALL(SetShowStyle), SIG_SINCE_SCI21LATE, SIGFOR_ALL, "ioiiiiii(r)(i)", NULL, NULL }, 918 { MAP_CALL(String), SIG_EVERYWHERE, "(.*)", kString_subops, NULL }, 919 { MAP_CALL(UpdatePlane), SIG_EVERYWHERE, "o", NULL, NULL }, 920 { MAP_CALL(UpdateScreenItem), SIG_EVERYWHERE, "o", NULL, NULL }, 921 { MAP_CALL(ObjectIntersect), SIG_EVERYWHERE, "oo", NULL, NULL }, 922 { MAP_CALL(EditText), SIG_EVERYWHERE, "o", NULL, NULL }, 923 { MAP_CALL(MakeSaveCatName), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "rr", NULL, NULL }, 924 { MAP_CALL(MakeSaveFileName), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "rri", NULL, NULL }, 925 { MAP_CALL(SetScroll), SIG_EVERYWHERE, "oiiii(i)(i)", NULL, NULL }, 926 { MAP_CALL(PalCycle), SIG_EVERYWHERE, "(.*)", kPalCycle_subops, NULL }, 927 928 // SCI2 Empty functions 929 930 // Debug function used to track resources 931 { MAP_EMPTY(ResourceTrack), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 932 // Future TODO: This call is used in the floppy version of QFG4 to add 933 // vibration to exotic mice with force feedback, such as the Logitech 934 // Cyberman and Wingman mice. Since this is only used for very exotic 935 // hardware and we have no direct and cross-platform way of communicating 936 // with them via SDL, plus we would probably need to make changes to common 937 // code, this call is mapped to an empty function for now as it's a rare 938 // feature not worth the effort. 939 { MAP_EMPTY(VibrateMouse), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 940 941 // Unused / debug SCI2 unused functions, always mapped to kDummy 942 943 // AddMagnify/DeleteMagnify are both called by script 64979 (the Magnifier 944 // object) in GK1 only. There is also an associated empty magnifier view 945 // (view 1), however, it doesn't seem to be used anywhere, as all the 946 // magnifier closeups (e.g. in scene 470) are normal views. Thus, these 947 // are marked as dummy, so if they're ever used the engine will error out. 948 { MAP_DUMMY(AddMagnify), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 949 { MAP_DUMMY(DeleteMagnify), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 950 { MAP_DUMMY(RepaintPlane), SIG_EVERYWHERE, "o", NULL, NULL }, 951 { MAP_DUMMY(InspectObject), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 952 // Profiler (same as SCI0-SCI1.1) 953 // Record (same as SCI0-SCI1.1) 954 // PlayBack (same as SCI0-SCI1.1) 955 { MAP_DUMMY(MonoOut), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 956 { MAP_DUMMY(SetFatalStr), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 957 { MAP_DUMMY(IntegrityChecking),SIG_EVERYWHERE, "(.*)", NULL, NULL }, 958 { MAP_DUMMY(CheckIntegrity), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 959 { MAP_DUMMY(MarkMemory), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 960 { MAP_DUMMY(GetHighItemPri), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 961 { MAP_DUMMY(ShowStylePercent), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 962 { MAP_DUMMY(InvertRect), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "(.*)", NULL, NULL }, 963 { MAP_CALL(InputText), SIG_EVERYWHERE, "rri", NULL, NULL }, 964 { MAP_CALL(TextWidth), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "ri", NULL, NULL }, 965 { MAP_CALL(PointSize), SIG_THRU_SCI21EARLY, SIGFOR_ALL, "i", NULL, NULL }, 966 967 // SCI2.1 Kernel Functions 968 { "CheckCDisc", kCheckCD, SIG_SCI21EARLY, SIGFOR_ALL, "(i)", NULL, NULL }, 969 { "GetSaveCDisc", kGetSavedCD, SIG_SCI21EARLY, SIGFOR_ALL, "", NULL, NULL }, 970 { MAP_CALL(CD), SIG_SINCE_SCI21MID, SIGFOR_ALL, "(.*)", kCD_subops, NULL }, 971 { MAP_CALL(IsOnMe), SIG_EVERYWHERE, "iioi", NULL, NULL }, 972 { MAP_CALL(List), SIG_SINCE_SCI21, SIGFOR_ALL, "(.*)", kList_subops, NULL }, 973 { MAP_CALL(MulDiv), SIG_EVERYWHERE, "iii", NULL, NULL }, 974 { MAP_CALL(PlayVMD), SIG_EVERYWHERE, "(.*)", kPlayVMD_subops, NULL }, 975 { MAP_CALL(Robot), SIG_EVERYWHERE, "(.*)", kRobot_subops, NULL }, 976 { MAP_CALL(Save), SIG_EVERYWHERE, "i(.*)", kSave_subops, NULL }, 977 { MAP_CALL(Text), SIG_SINCE_SCI21MID, SIGFOR_ALL, "i(.*)", kText_subops, NULL }, 978 { MAP_CALL(AddPicAt), SIG_EVERYWHERE, "oiii(i)(i)", NULL, NULL }, 979 { MAP_CALL(GetWindowsOption), SIG_EVERYWHERE, "i", NULL, NULL }, 980 { MAP_CALL(WinHelp), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 981 { MAP_CALL(GetConfig), SIG_EVERYWHERE, "ro", NULL, NULL }, 982 { MAP_CALL(GetSierraProfileInt), SIG_EVERYWHERE, "rri", NULL, NULL }, 983 { MAP_CALL(CelInfo), SIG_SINCE_SCI21MID, SIGFOR_ALL, "(.*)", kCelInfo_subops, NULL }, 984 { MAP_CALL(SetLanguage), SIG_SINCE_SCI21MID, SIGFOR_ALL, "r", NULL, NULL }, 985 { MAP_CALL(ScrollWindow), SIG_EVERYWHERE, "i(.*)", kScrollWindow_subops, NULL }, 986 { MAP_CALL(SetFontRes), SIG_SCI21EARLY, SIGFOR_ALL, "ii", NULL, NULL }, 987 { MAP_CALL(Font), SIG_SINCE_SCI21MID, SIGFOR_ALL, "i(.*)", kFont_subops, NULL }, 988 { MAP_CALL(Bitmap), SIG_EVERYWHERE, "i([.!]*)", kBitmap_subops, NULL }, 989 { MAP_CALL(AddLine), SIG_EVERYWHERE, "oiiii(iiiii)", NULL, NULL }, 990 // The first argument is a ScreenItem instance ID that is created by the 991 // engine, not the VM; as a result, in ScummVM, this argument looks like 992 // an integer and not an object, although it is an object reference. 993 { MAP_CALL(UpdateLine), SIG_EVERYWHERE, "ioiiii(iiiii)", NULL, NULL }, 994 { MAP_CALL(DeleteLine), SIG_EVERYWHERE, "io", NULL, NULL }, 995 996 // SCI2.1 Empty Functions 997 998 // Debug function, used in of Shivers (demo and full). It's marked as a 999 // stub in the original interpreters, but it gets called by the game scripts. 1000 // Usually, it gets called with a string (which is the output format) and a 1001 // variable number of parameters 1002 { MAP_CALL(PrintDebug), SIG_SCI32, SIGFOR_ALL, "r(.*)", NULL, NULL }, 1003 1004 // SetWindowsOption is used to set Windows specific options, like for example the title bar visibility of 1005 // the game window in Phantasmagoria 2. We ignore these settings completely. 1006 { MAP_EMPTY(SetWindowsOption), SIG_EVERYWHERE, "ii", NULL, NULL }, 1007 1008 // Debug function called whenever the current room changes 1009 { MAP_EMPTY(NewRoom), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1010 1011 // Unused / debug SCI2.1 unused functions, always mapped to kDummy 1012 1013 // The debug functions are called from the inbuilt debugger or polygon 1014 // editor in SCI2.1 games. Related objects are: PEditor, EditablePolygon, 1015 // aeDisplayClass and scalerCode 1016 { MAP_DUMMY(FindSelector), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1017 { MAP_DUMMY(FindClass), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1018 { MAP_DUMMY(CelRect), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1019 { MAP_DUMMY(BaseLineSpan), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1020 { MAP_CALL(CelLink), SIG_SINCE_SCI21MID, SIGFOR_ALL, "(.*)", kCelLink_subops, NULL }, 1021 { MAP_DUMMY(AddPolygon), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1022 { MAP_DUMMY(DeletePolygon), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1023 { MAP_DUMMY(UpdatePolygon), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1024 { MAP_DUMMY(Table), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1025 { MAP_DUMMY(LoadChunk), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1026 { MAP_DUMMY(Priority), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1027 { MAP_CALL(WinDLL), SIG_SINCE_SCI21MID, SIGFOR_ALL, "ir(r)", NULL, NULL }, 1028 { MAP_DUMMY(DeletePic), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1029 { MAP_DUMMY(GetSierraProfileString), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1030 1031 // Unused / debug functions in the in-between SCI2.1 interpreters 1032 { MAP_DUMMY(PreloadResource), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1033 { MAP_DUMMY(TestPoly), SIG_EVERYWHERE, "(.*)", NULL, NULL }, 1034 1035 // Used by Phantasmagoria 1, script 64981 (used in the chase scene) 1036 { MAP_CALL(SetHotRectangles), SIG_SINCE_SCI21MID, SIGFOR_ALL, "i(r)", NULL, NULL }, 1037 1038 // Used by SQ6 to scroll through the inventory via the up/down buttons 1039 { MAP_CALL(MovePlaneItems), SIG_SINCE_SCI21, SIGFOR_ALL, "oii(i)", NULL, NULL }, 1040 1041 { MAP_CALL(SetPalStyleRange), SIG_EVERYWHERE, "ii", NULL, NULL }, 1042 1043 { MAP_CALL(MorphOn), SIG_EVERYWHERE, "", NULL, NULL }, 1044 1045 // SCI3 Kernel Functions 1046 { MAP_EMPTY(Minimize), SIG_SCI3, SIGFOR_ALL, "(.*)", NULL, NULL }, 1047 { MAP_CALL(PlayDuck), SIG_SCI3, SIGFOR_ALL, "(.*)", kPlayDuck_subops,NULL }, 1048 { MAP_CALL(WebConnect), SIG_SCI3, SIGFOR_ALL, "(r)", NULL, NULL }, 1049 { MAP_CALL(WinExec), SIG_SCI3, SIGFOR_ALL, "r", NULL, NULL }, 1050 #endif 1051 1052 { NULL, NULL, SIG_EVERYWHERE, NULL, NULL, NULL } 1053 }; 1054 1055 /** Default kernel name table. */ 1056 static const char *const s_defaultKernelNames[] = { 1057 /*0x00*/ "Load", 1058 /*0x01*/ "UnLoad", 1059 /*0x02*/ "ScriptID", 1060 /*0x03*/ "DisposeScript", 1061 /*0x04*/ "Clone", 1062 /*0x05*/ "DisposeClone", 1063 /*0x06*/ "IsObject", 1064 /*0x07*/ "RespondsTo", 1065 /*0x08*/ "DrawPic", 1066 /*0x09*/ "Show", 1067 /*0x0a*/ "PicNotValid", 1068 /*0x0b*/ "Animate", 1069 /*0x0c*/ "SetNowSeen", 1070 /*0x0d*/ "NumLoops", 1071 /*0x0e*/ "NumCels", 1072 /*0x0f*/ "CelWide", 1073 /*0x10*/ "CelHigh", 1074 /*0x11*/ "DrawCel", 1075 /*0x12*/ "AddToPic", 1076 /*0x13*/ "NewWindow", 1077 /*0x14*/ "GetPort", 1078 /*0x15*/ "SetPort", 1079 /*0x16*/ "DisposeWindow", 1080 /*0x17*/ "DrawControl", 1081 /*0x18*/ "HiliteControl", 1082 /*0x19*/ "EditControl", 1083 /*0x1a*/ "TextSize", 1084 /*0x1b*/ "Display", 1085 /*0x1c*/ "GetEvent", 1086 /*0x1d*/ "GlobalToLocal", 1087 /*0x1e*/ "LocalToGlobal", 1088 /*0x1f*/ "MapKeyToDir", 1089 /*0x20*/ "DrawMenuBar", 1090 /*0x21*/ "MenuSelect", 1091 /*0x22*/ "AddMenu", 1092 /*0x23*/ "DrawStatus", 1093 /*0x24*/ "Parse", 1094 /*0x25*/ "Said", 1095 /*0x26*/ "SetSynonyms", // Portrait (KQ6 hires) 1096 /*0x27*/ "HaveMouse", 1097 /*0x28*/ "SetCursor", 1098 // FOpen (SCI0) 1099 // FPuts (SCI0) 1100 // FGets (SCI0) 1101 // FClose (SCI0) 1102 /*0x29*/ "SaveGame", 1103 /*0x2a*/ "RestoreGame", 1104 /*0x2b*/ "RestartGame", 1105 /*0x2c*/ "GameIsRestarting", 1106 /*0x2d*/ "DoSound", 1107 /*0x2e*/ "NewList", 1108 /*0x2f*/ "DisposeList", 1109 /*0x30*/ "NewNode", 1110 /*0x31*/ "FirstNode", 1111 /*0x32*/ "LastNode", 1112 /*0x33*/ "EmptyList", 1113 /*0x34*/ "NextNode", 1114 /*0x35*/ "PrevNode", 1115 /*0x36*/ "NodeValue", 1116 /*0x37*/ "AddAfter", 1117 /*0x38*/ "AddToFront", 1118 /*0x39*/ "AddToEnd", 1119 /*0x3a*/ "FindKey", 1120 /*0x3b*/ "DeleteKey", 1121 /*0x3c*/ "Random", 1122 /*0x3d*/ "Abs", 1123 /*0x3e*/ "Sqrt", 1124 /*0x3f*/ "GetAngle", 1125 /*0x40*/ "GetDistance", 1126 /*0x41*/ "Wait", 1127 /*0x42*/ "GetTime", 1128 /*0x43*/ "StrEnd", 1129 /*0x44*/ "StrCat", 1130 /*0x45*/ "StrCmp", 1131 /*0x46*/ "StrLen", 1132 /*0x47*/ "StrCpy", 1133 /*0x48*/ "Format", 1134 /*0x49*/ "GetFarText", 1135 /*0x4a*/ "ReadNumber", 1136 /*0x4b*/ "BaseSetter", 1137 /*0x4c*/ "DirLoop", 1138 /*0x4d*/ "CanBeHere", // CantBeHere in newer SCI versions 1139 /*0x4e*/ "OnControl", 1140 /*0x4f*/ "InitBresen", 1141 /*0x50*/ "DoBresen", 1142 /*0x51*/ "Platform", // DoAvoider (SCI0) 1143 /*0x52*/ "SetJump", 1144 /*0x53*/ "SetDebug", // for debugging 1145 /*0x54*/ "InspectObj", // for debugging 1146 /*0x55*/ "ShowSends", // for debugging 1147 /*0x56*/ "ShowObjs", // for debugging 1148 /*0x57*/ "ShowFree", // for debugging 1149 /*0x58*/ "MemoryInfo", 1150 /*0x59*/ "StackUsage", // for debugging 1151 /*0x5a*/ "Profiler", // for debugging 1152 /*0x5b*/ "GetMenu", 1153 /*0x5c*/ "SetMenu", 1154 /*0x5d*/ "GetSaveFiles", 1155 /*0x5e*/ "GetCWD", 1156 /*0x5f*/ "CheckFreeSpace", 1157 /*0x60*/ "ValidPath", 1158 /*0x61*/ "CoordPri", 1159 /*0x62*/ "StrAt", 1160 /*0x63*/ "DeviceInfo", 1161 /*0x64*/ "GetSaveDir", 1162 /*0x65*/ "CheckSaveGame", 1163 /*0x66*/ "ShakeScreen", 1164 /*0x67*/ "FlushResources", 1165 /*0x68*/ "SinMult", 1166 /*0x69*/ "CosMult", 1167 /*0x6a*/ "SinDiv", 1168 /*0x6b*/ "CosDiv", 1169 /*0x6c*/ "Graph", 1170 /*0x6d*/ "Joystick", 1171 // End of kernel function table for SCI0 1172 /*0x6e*/ "ShiftScreen", // never called? 1173 /*0x6f*/ "Palette", 1174 /*0x70*/ "MemorySegment", 1175 /*0x71*/ "Intersections", // MoveCursor (SCI1 late), PalVary (SCI1.1) 1176 /*0x72*/ "Memory", 1177 /*0x73*/ "ListOps", // never called? 1178 /*0x74*/ "FileIO", 1179 /*0x75*/ "DoAudio", 1180 /*0x76*/ "DoSync", 1181 /*0x77*/ "AvoidPath", 1182 /*0x78*/ "Sort", // StrSplit (SCI01) 1183 /*0x79*/ "ATan", // never called? 1184 /*0x7a*/ "Lock", 1185 /*0x7b*/ "StrSplit", 1186 /*0x7c*/ "GetMessage", // Message (SCI1.1) 1187 /*0x7d*/ "IsItSkip", 1188 /*0x7e*/ "MergePoly", 1189 /*0x7f*/ "ResCheck", 1190 /*0x80*/ "AssertPalette", 1191 /*0x81*/ "TextColors", 1192 /*0x82*/ "TextFonts", 1193 /*0x83*/ "Record", // for debugging 1194 /*0x84*/ "PlayBack", // for debugging 1195 /*0x85*/ "ShowMovie", 1196 /*0x86*/ "SetVideoMode", 1197 /*0x87*/ "SetQuitStr", 1198 /*0x88*/ "DbugStr", // for debugging 1199 /*0x89*/ "Empty", 1200 /*0x8a*/ "Empty" 1201 }; 1202 1203 #ifdef ENABLE_SCI32 1204 1205 // NOTE: 0x72-0x79, 0x85-0x86, 0x88 are from the GK2 demo (which has debug support) and are 1206 // just Dummy in other SCI2 games. 1207 static const char *const sci2_default_knames[] = { 1208 /*0x00*/ "Load", 1209 /*0x01*/ "UnLoad", 1210 /*0x02*/ "ScriptID", 1211 /*0x03*/ "DisposeScript", 1212 /*0x04*/ "Lock", 1213 /*0x05*/ "ResCheck", 1214 /*0x06*/ "Purge", 1215 /*0x07*/ "Clone", 1216 /*0x08*/ "DisposeClone", 1217 /*0x09*/ "RespondsTo", 1218 /*0x0a*/ "SetNowSeen", 1219 /*0x0b*/ "NumLoops", 1220 /*0x0c*/ "NumCels", 1221 /*0x0d*/ "CelWide", 1222 /*0x0e*/ "CelHigh", 1223 /*0x0f*/ "GetHighPlanePri", 1224 /*0x10*/ "GetHighItemPri", // unused function 1225 /*0x11*/ "ShakeScreen", 1226 /*0x12*/ "OnMe", 1227 /*0x13*/ "ShowMovie", 1228 /*0x14*/ "SetVideoMode", 1229 /*0x15*/ "AddScreenItem", 1230 /*0x16*/ "DeleteScreenItem", 1231 /*0x17*/ "UpdateScreenItem", 1232 /*0x18*/ "FrameOut", 1233 /*0x19*/ "AddPlane", 1234 /*0x1a*/ "DeletePlane", 1235 /*0x1b*/ "UpdatePlane", 1236 /*0x1c*/ "RepaintPlane", // unused function 1237 /*0x1d*/ "SetShowStyle", 1238 /*0x1e*/ "ShowStylePercent", // unused function 1239 /*0x1f*/ "SetScroll", 1240 /*0x20*/ "AddMagnify", 1241 /*0x21*/ "DeleteMagnify", 1242 /*0x22*/ "IsHiRes", 1243 /*0x23*/ "Graph", // Robot in early SCI2.1 games with a SCI2 kernel table 1244 /*0x24*/ "InvertRect", // only in SCI2, not used in any SCI2 game 1245 /*0x25*/ "TextSize", 1246 /*0x26*/ "Message", 1247 /*0x27*/ "TextColors", 1248 /*0x28*/ "TextFonts", 1249 /*0x29*/ "Dummy", 1250 /*0x2a*/ "SetQuitStr", 1251 /*0x2b*/ "EditText", 1252 /*0x2c*/ "InputText", 1253 /*0x2d*/ "CreateTextBitmap", 1254 /*0x2e*/ "DisposeTextBitmap", // Priority in early SCI2.1 games with a SCI2 kernel table 1255 /*0x2f*/ "GetEvent", 1256 /*0x30*/ "GlobalToLocal", 1257 /*0x31*/ "LocalToGlobal", 1258 /*0x32*/ "MapKeyToDir", 1259 /*0x33*/ "HaveMouse", 1260 /*0x34*/ "SetCursor", 1261 /*0x35*/ "VibrateMouse", 1262 /*0x36*/ "SaveGame", 1263 /*0x37*/ "RestoreGame", 1264 /*0x38*/ "RestartGame", 1265 /*0x39*/ "GameIsRestarting", 1266 /*0x3a*/ "MakeSaveCatName", 1267 /*0x3b*/ "MakeSaveFileName", 1268 /*0x3c*/ "GetSaveFiles", 1269 /*0x3d*/ "GetSaveDir", 1270 /*0x3e*/ "CheckSaveGame", 1271 /*0x3f*/ "CheckFreeSpace", 1272 /*0x40*/ "DoSound", 1273 /*0x41*/ "DoAudio", 1274 /*0x42*/ "DoSync", 1275 /*0x43*/ "NewList", 1276 /*0x44*/ "DisposeList", 1277 /*0x45*/ "NewNode", 1278 /*0x46*/ "FirstNode", 1279 /*0x47*/ "LastNode", 1280 /*0x48*/ "EmptyList", 1281 /*0x49*/ "NextNode", 1282 /*0x4a*/ "PrevNode", 1283 /*0x4b*/ "NodeValue", 1284 /*0x4c*/ "AddAfter", 1285 /*0x4d*/ "AddToFront", 1286 /*0x4e*/ "AddToEnd", 1287 /*0x4f*/ "Dummy", 1288 /*0x50*/ "Dummy", 1289 /*0x51*/ "FindKey", 1290 /*0x52*/ "Dummy", 1291 /*0x53*/ "Dummy", 1292 /*0x54*/ "Dummy", 1293 /*0x55*/ "DeleteKey", 1294 /*0x56*/ "Dummy", 1295 /*0x57*/ "Dummy", 1296 /*0x58*/ "ListAt", 1297 /*0x59*/ "ListIndexOf", 1298 /*0x5a*/ "ListEachElementDo", 1299 /*0x5b*/ "ListFirstTrue", 1300 /*0x5c*/ "ListAllTrue", 1301 /*0x5d*/ "Random", 1302 /*0x5e*/ "Abs", 1303 /*0x5f*/ "Sqrt", 1304 /*0x60*/ "GetAngle", 1305 /*0x61*/ "GetDistance", 1306 /*0x62*/ "ATan", 1307 /*0x63*/ "SinMult", 1308 /*0x64*/ "CosMult", 1309 /*0x65*/ "SinDiv", 1310 /*0x66*/ "CosDiv", 1311 /*0x67*/ "GetTime", 1312 /*0x68*/ "Platform", 1313 /*0x69*/ "BaseSetter", 1314 /*0x6a*/ "DirLoop", 1315 /*0x6b*/ "CantBeHere", 1316 /*0x6c*/ "InitBresen", 1317 /*0x6d*/ "DoBresen", 1318 /*0x6e*/ "SetJump", 1319 /*0x6f*/ "AvoidPath", 1320 /*0x70*/ "InPolygon", 1321 /*0x71*/ "MergePoly", 1322 /*0x72*/ "SetDebug", 1323 /*0x73*/ "InspectObject", // for debugging 1324 /*0x74*/ "MemoryInfo", 1325 /*0x75*/ "Profiler", // for debugging 1326 /*0x76*/ "Record", // for debugging 1327 /*0x77*/ "PlayBack", // for debugging 1328 /*0x78*/ "MonoOut", // for debugging 1329 /*0x79*/ "SetFatalStr", // for debugging 1330 /*0x7a*/ "GetCWD", 1331 /*0x7b*/ "ValidPath", 1332 /*0x7c*/ "FileIO", 1333 /*0x7d*/ "Dummy", 1334 /*0x7e*/ "DeviceInfo", 1335 /*0x7f*/ "Palette", 1336 /*0x80*/ "PalVary", 1337 /*0x81*/ "PalCycle", 1338 /*0x82*/ "Array", 1339 /*0x83*/ "String", 1340 /*0x84*/ "RemapColors", 1341 /*0x85*/ "IntegrityChecking", // for debugging 1342 /*0x86*/ "CheckIntegrity", // for debugging 1343 /*0x87*/ "ObjectIntersect", 1344 /*0x88*/ "MarkMemory", // for debugging 1345 /*0x89*/ "TextWidth", 1346 /*0x8a*/ "PointSize", 1347 1348 /*0x8b*/ "AddLine", 1349 /*0x8c*/ "DeleteLine", 1350 /*0x8d*/ "UpdateLine", 1351 /*0x8e*/ "AddPolygon", 1352 /*0x8f*/ "DeletePolygon", 1353 /*0x90*/ "UpdatePolygon", 1354 /*0x91*/ "Bitmap", 1355 /*0x92*/ "ScrollWindow", 1356 /*0x93*/ "SetFontRes", 1357 /*0x94*/ "MovePlaneItems", 1358 /*0x95*/ "PreloadResource", 1359 /*0x96*/ "Dummy", 1360 /*0x97*/ "ResourceTrack", 1361 /*0x98*/ "CheckCDisc", 1362 /*0x99*/ "GetSaveCDisc", 1363 /*0x9a*/ "TestPoly", 1364 /*0x9b*/ "WinHelp", 1365 /*0x9c*/ "LoadChunk", 1366 /*0x9d*/ "SetPalStyleRange", 1367 /*0x9e*/ "AddPicAt", 1368 /*0x9f*/ "MessageBox" 1369 }; 1370 1371 static const char *const sci21_default_knames[] = { 1372 /*0x00*/ "Load", 1373 /*0x01*/ "UnLoad", 1374 /*0x02*/ "ScriptID", 1375 /*0x03*/ "DisposeScript", 1376 /*0x04*/ "Lock", 1377 /*0x05*/ "ResCheck", 1378 /*0x06*/ "Purge", 1379 /*0x07*/ "SetLanguage", 1380 /*0x08*/ "Dummy", 1381 /*0x09*/ "Dummy", 1382 /*0x0a*/ "Clone", 1383 /*0x0b*/ "DisposeClone", 1384 /*0x0c*/ "RespondsTo", 1385 /*0x0d*/ "FindSelector", 1386 /*0x0e*/ "FindClass", 1387 /*0x0f*/ "Dummy", 1388 /*0x10*/ "Dummy", 1389 /*0x11*/ "Dummy", 1390 /*0x12*/ "Dummy", 1391 /*0x13*/ "Dummy", 1392 /*0x14*/ "SetNowSeen", 1393 /*0x15*/ "NumLoops", 1394 /*0x16*/ "NumCels", 1395 /*0x17*/ "IsOnMe", 1396 /*0x18*/ "AddMagnify", // dummy in SCI3 1397 /*0x19*/ "DeleteMagnify", // dummy in SCI3 1398 /*0x1a*/ "CelRect", 1399 /*0x1b*/ "BaseLineSpan", 1400 /*0x1c*/ "CelWide", 1401 /*0x1d*/ "CelHigh", 1402 /*0x1e*/ "AddScreenItem", 1403 /*0x1f*/ "DeleteScreenItem", 1404 /*0x20*/ "UpdateScreenItem", 1405 /*0x21*/ "FrameOut", 1406 /*0x22*/ "CelInfo", 1407 /*0x23*/ "Bitmap", 1408 /*0x24*/ "CelLink", 1409 /*0x25*/ "Dummy", 1410 /*0x26*/ "Dummy", 1411 /*0x27*/ "Dummy", 1412 /*0x28*/ "AddPlane", 1413 /*0x29*/ "DeletePlane", 1414 /*0x2a*/ "UpdatePlane", 1415 /*0x2b*/ "RepaintPlane", 1416 /*0x2c*/ "GetHighPlanePri", 1417 /*0x2d*/ "GetHighItemPri", // unused function 1418 /*0x2e*/ "SetShowStyle", 1419 /*0x2f*/ "ShowStylePercent", // unused function 1420 /*0x30*/ "SetScroll", // dummy in SCI3 1421 /*0x31*/ "MovePlaneItems", 1422 /*0x32*/ "ShakeScreen", 1423 /*0x33*/ "Dummy", 1424 /*0x34*/ "Dummy", 1425 /*0x35*/ "Dummy", 1426 /*0x36*/ "Dummy", 1427 /*0x37*/ "IsHiRes", 1428 /*0x38*/ "SetVideoMode", 1429 /*0x39*/ "ShowMovie", // dummy in SCI3 1430 /*0x3a*/ "Robot", 1431 /*0x3b*/ "CreateTextBitmap", 1432 /*0x3c*/ "Random", 1433 /*0x3d*/ "Abs", 1434 /*0x3e*/ "Sqrt", 1435 /*0x3f*/ "GetAngle", 1436 /*0x40*/ "GetDistance", 1437 /*0x41*/ "ATan", 1438 /*0x42*/ "SinMult", 1439 /*0x43*/ "CosMult", 1440 /*0x44*/ "SinDiv", 1441 /*0x45*/ "CosDiv", 1442 /*0x46*/ "Text", 1443 /*0x47*/ "Dummy", 1444 /*0x48*/ "Message", 1445 /*0x49*/ "Font", 1446 /*0x4a*/ "EditText", 1447 /*0x4b*/ "InputText", 1448 /*0x4c*/ "ScrollWindow", // Dummy in SCI3 1449 /*0x4d*/ "Dummy", 1450 /*0x4e*/ "Dummy", 1451 /*0x4f*/ "Dummy", 1452 /*0x50*/ "GetEvent", 1453 /*0x51*/ "GlobalToLocal", 1454 /*0x52*/ "LocalToGlobal", 1455 /*0x53*/ "MapKeyToDir", 1456 /*0x54*/ "HaveMouse", 1457 /*0x55*/ "SetCursor", 1458 /*0x56*/ "VibrateMouse", // Dummy in SCI3 1459 /*0x57*/ "Dummy", 1460 /*0x58*/ "Dummy", 1461 /*0x59*/ "Dummy", 1462 /*0x5a*/ "List", 1463 /*0x5b*/ "Array", 1464 /*0x5c*/ "String", 1465 /*0x5d*/ "FileIO", 1466 /*0x5e*/ "BaseSetter", 1467 /*0x5f*/ "DirLoop", 1468 /*0x60*/ "CantBeHere", 1469 /*0x61*/ "InitBresen", 1470 /*0x62*/ "DoBresen", 1471 /*0x63*/ "SetJump", 1472 /*0x64*/ "AvoidPath", // dummy in SCI3 1473 /*0x65*/ "InPolygon", 1474 /*0x66*/ "MergePoly", // dummy in SCI3 1475 /*0x67*/ "ObjectIntersect", 1476 /*0x68*/ "Dummy", 1477 /*0x69*/ "MemoryInfo", 1478 /*0x6a*/ "DeviceInfo", 1479 /*0x6b*/ "Palette", 1480 /*0x6c*/ "PalVary", 1481 /*0x6d*/ "PalCycle", 1482 /*0x6e*/ "RemapColors", 1483 /*0x6f*/ "AddLine", 1484 /*0x70*/ "DeleteLine", 1485 /*0x71*/ "UpdateLine", 1486 /*0x72*/ "AddPolygon", 1487 /*0x73*/ "DeletePolygon", 1488 /*0x74*/ "UpdatePolygon", 1489 /*0x75*/ "DoSound", 1490 /*0x76*/ "DoAudio", 1491 /*0x77*/ "DoSync", 1492 /*0x78*/ "Save", 1493 /*0x79*/ "GetTime", 1494 /*0x7a*/ "Platform", 1495 /*0x7b*/ "CD", 1496 /*0x7c*/ "SetQuitStr", 1497 /*0x7d*/ "GetConfig", 1498 /*0x7e*/ "Table", 1499 /*0x7f*/ "WinHelp", // Windows only 1500 /*0x80*/ "Dummy", 1501 /*0x81*/ "Empty", // called when clicking the On-line Help button in Phant2 control panel 1502 /*0x82*/ "Dummy", 1503 /*0x83*/ "PrintDebug", // debug function, used by Shivers (demo and full) 1504 /*0x84*/ "Dummy", 1505 /*0x85*/ "Dummy", 1506 /*0x86*/ "Dummy", 1507 /*0x87*/ "Dummy", 1508 /*0x88*/ "Dummy", 1509 /*0x89*/ "Dummy", 1510 /*0x8a*/ "LoadChunk", 1511 /*0x8b*/ "SetPalStyleRange", 1512 /*0x8c*/ "AddPicAt", 1513 /*0x8d*/ "Dummy", // MessageBox in SCI3 1514 /*0x8e*/ "NewRoom", // debug function 1515 /*0x8f*/ "Dummy", 1516 /*0x90*/ "Priority", 1517 /*0x91*/ "MorphOn", 1518 /*0x92*/ "PlayVMD", 1519 /*0x93*/ "SetHotRectangles", 1520 /*0x94*/ "MulDiv", 1521 /*0x95*/ "GetSierraProfileInt", // , Windows only 1522 /*0x96*/ "GetSierraProfileString", // , Windows only 1523 /*0x97*/ "SetWindowsOption", // Windows only 1524 /*0x98*/ "GetWindowsOption", // Windows only 1525 /*0x99*/ "WinDLL", // Windows only 1526 /*0x9a*/ "Dummy", 1527 /*0x9b*/ "Dummy", // Minimize in SCI3 1528 /*0x9c*/ "DeletePic", 1529 // == SCI3 only =============== 1530 /*0x9d*/ "Dummy", 1531 /*0x9e*/ "WebConnect", 1532 /*0x9f*/ "Dummy", 1533 /*0xa0*/ "PlayDuck", 1534 /*0xa1*/ "WinExec" 1535 }; 1536 1537 #endif 1538 1539 // Base set of opcode formats. They're copied and adjusted slightly in 1540 // script_adjust_opcode_format depending on SCI version. 1541 static const opcode_format g_base_opcode_formats[128][4] = { 1542 // 00 - 03 / bnot, add, sub, mul 1543 {Script_None}, {Script_None}, {Script_None}, {Script_None}, 1544 // 04 - 07 / div, mod, shr, shl 1545 {Script_None}, {Script_None}, {Script_None}, {Script_None}, 1546 // 08 - 0B / xor, and, or, neg 1547 {Script_None}, {Script_None}, {Script_None}, {Script_None}, 1548 // 0C - 0F / not, eq, ne, gt 1549 {Script_None}, {Script_None}, {Script_None}, {Script_None}, 1550 // 10 - 13 / ge, lt, le, ugt 1551 {Script_None}, {Script_None}, {Script_None}, {Script_None}, 1552 // 14 - 17 / uge, ult, ule, bt 1553 {Script_None}, {Script_None}, {Script_None}, {Script_SRelative}, 1554 // 18 - 1B / bnt, jmp, ldi, push 1555 {Script_SRelative}, {Script_SRelative}, {Script_SVariable}, {Script_None}, 1556 // 1C - 1F / pushi, toss, dup, link 1557 {Script_SVariable}, {Script_None}, {Script_None}, {Script_Variable}, 1558 // 20 - 23 / call, callk, callb, calle 1559 {Script_SRelative, Script_Byte}, {Script_Variable, Script_Byte}, {Script_Variable, Script_Byte}, {Script_Variable, Script_SVariable, Script_Byte}, 1560 // 24 - 27 / ret, send, dummy, dummy 1561 {Script_End}, {Script_Byte}, {Script_Invalid}, {Script_Invalid}, 1562 // 28 - 2B / class, dummy, self, super 1563 {Script_Variable}, {Script_Invalid}, {Script_Byte}, {Script_Variable, Script_Byte}, 1564 // 2C - 2F / rest, lea, selfID, dummy 1565 {Script_SVariable}, {Script_SVariable, Script_Variable}, {Script_None}, {Script_Invalid}, 1566 // 30 - 33 / pprev, pToa, aTop, pTos 1567 {Script_None}, {Script_Property}, {Script_Property}, {Script_Property}, 1568 // 34 - 37 / sTop, ipToa, dpToa, ipTos 1569 {Script_Property}, {Script_Property}, {Script_Property}, {Script_Property}, 1570 // 38 - 3B / dpTos, lofsa, lofss, push0 1571 {Script_Property}, {Script_SRelative}, {Script_SRelative}, {Script_None}, 1572 // 3C - 3F / push1, push2, pushSelf, line 1573 {Script_None}, {Script_None}, {Script_None}, {Script_Word}, 1574 // ------------------------------------------------------------------------ 1575 // 40 - 43 / lag, lal, lat, lap 1576 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1577 // 44 - 47 / lsg, lsl, lst, lsp 1578 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1579 // 48 - 4B / lagi, lali, lati, lapi 1580 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1581 // 4C - 4F / lsgi, lsli, lsti, lspi 1582 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1583 // ------------------------------------------------------------------------ 1584 // 50 - 53 / sag, sal, sat, sap 1585 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1586 // 54 - 57 / ssg, ssl, sst, ssp 1587 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1588 // 58 - 5B / sagi, sali, sati, sapi 1589 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1590 // 5C - 5F / ssgi, ssli, ssti, sspi 1591 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1592 // ------------------------------------------------------------------------ 1593 // 60 - 63 / plusag, plusal, plusat, plusap 1594 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1595 // 64 - 67 / plussg, plussl, plusst, plussp 1596 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1597 // 68 - 6B / plusagi, plusali, plusati, plusapi 1598 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1599 // 6C - 6F / plussgi, plussli, plussti, plusspi 1600 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1601 // ------------------------------------------------------------------------ 1602 // 70 - 73 / minusag, minusal, minusat, minusap 1603 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1604 // 74 - 77 / minussg, minussl, minusst, minussp 1605 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1606 // 78 - 7B / minusagi, minusali, minusati, minusapi 1607 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param}, 1608 // 7C - 7F / minussgi, minussli, minussti, minusspi 1609 {Script_Global}, {Script_Local}, {Script_Temp}, {Script_Param} 1610 }; 1611 1612 } // End of namespace Sci 1613 1614 #endif // SCI_ENGINE_KERNEL_TABLES_H 1615