Powered by ViewCVS 1.0-dev
| 1 : | anton | 1.1 | /* common header file |
| 2 : | |||
| 3 : | anton | 1.99 | Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2006,2007,2008 Free Software Foundation, Inc. |
| 4 : | anton | 1.1 | |
| 5 : | This file is part of Gforth. | ||
| 6 : | |||
| 7 : | Gforth is free software; you can redistribute it and/or | ||
| 8 : | modify it under the terms of the GNU General Public License | ||
| 9 : | anton | 1.89 | as published by the Free Software Foundation, either version 3 |
| 10 : | anton | 1.1 | 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 : | anton | 1.89 | along with this program; if not, see http://www.gnu.org/licenses/. |
| 19 : | anton | 1.1 | */ |
| 20 : | |||
| 21 : | #include "config.h" | ||
| 22 : | anton | 1.90 | #include "128bit.h" |
| 23 : | anton | 1.18 | #include <stdio.h> |
| 24 : | anton | 1.35 | #include <sys/time.h> |
| 25 : | #include <unistd.h> | ||
| 26 : | pazsan | 1.95 | #ifndef STANDALONE |
| 27 : | anton | 1.103 | #if defined(HAVE_LIBLTDL) |
| 28 : | anton | 1.87 | #include <ltdl.h> |
| 29 : | pazsan | 1.95 | #endif |
| 30 : | anton | 1.103 | #endif |
| 31 : | anton | 1.1 | |
| 32 : | anton | 1.93 | #if !defined(FORCE_LL) && !defined(BUGGY_LONG_LONG) |
| 33 : | #define BUGGY_LONG_LONG | ||
| 34 : | #endif | ||
| 35 : | |||
| 36 : | anton | 1.32 | #if defined(DOUBLY_INDIRECT)||defined(INDIRECT_THREADED)||defined(VM_PROFILING) |
| 37 : | #define NO_DYNAMIC | ||
| 38 : | #endif | ||
| 39 : | |||
| 40 : | anton | 1.1 | #if defined(DOUBLY_INDIRECT) |
| 41 : | # undef DIRECT_THREADED | ||
| 42 : | # undef INDIRECT_THREADED | ||
| 43 : | # define INDIRECT_THREADED | ||
| 44 : | #endif | ||
| 45 : | |||
| 46 : | anton | 1.57 | #if defined(GFORTH_DEBUGGING) || defined(INDIRECT_THREADED) || defined(DOUBLY_INDIRECT) || defined(VM_PROFILING) |
| 47 : | anton | 1.23 | # undef USE_TOS |
| 48 : | # undef USE_FTOS | ||
| 49 : | anton | 1.56 | # undef USE_NO_TOS |
| 50 : | # undef USE_NO_FTOS | ||
| 51 : | anton | 1.23 | # define USE_NO_TOS |
| 52 : | # define USE_NO_FTOS | ||
| 53 : | anton | 1.57 | |
| 54 : | #define PRIM_I "prim.i" | ||
| 55 : | #define PRIM_LAB_I "prim_lab.i" | ||
| 56 : | #define PRIM_NAMES_I "prim_names.i" | ||
| 57 : | #define PRIM_SUPEREND_I "prim_superend.i" | ||
| 58 : | #define PRIM_NUM_I "prim_num.i" | ||
| 59 : | #define PRIM_GRP_I "prim_grp.i" | ||
| 60 : | #define COSTS_I "costs.i" | ||
| 61 : | #define SUPER2_I "super2.i" | ||
| 62 : | anton | 1.58 | /* #define PROFILE_I "profile.i" */ |
| 63 : | anton | 1.57 | |
| 64 : | #else | ||
| 65 : | /* gforth-fast or gforth-native */ | ||
| 66 : | anton | 1.59 | # undef USE_TOS |
| 67 : | # undef USE_FTOS | ||
| 68 : | # undef USE_NO_TOS | ||
| 69 : | # undef USE_NO_FTOS | ||
| 70 : | # define USE_TOS | ||
| 71 : | anton | 1.57 | |
| 72 : | #define PRIM_I "prim-fast.i" | ||
| 73 : | #define PRIM_LAB_I "prim_lab-fast.i" | ||
| 74 : | #define PRIM_NAMES_I "prim_names-fast.i" | ||
| 75 : | #define PRIM_SUPEREND_I "prim_superend-fast.i" | ||
| 76 : | #define PRIM_NUM_I "prim_num-fast.i" | ||
| 77 : | #define PRIM_GRP_I "prim_grp-fast.i" | ||
| 78 : | #define COSTS_I "costs-fast.i" | ||
| 79 : | #define SUPER2_I "super2-fast.i" | ||
| 80 : | anton | 1.58 | /* profile.c uses profile.i but does not define VM_PROFILING */ |
| 81 : | /* #define PROFILE_I "profile-fast.i" */ | ||
| 82 : | anton | 1.57 | |
| 83 : | anton | 1.23 | #endif |
| 84 : | anton | 1.57 | |
| 85 : | |||
| 86 : | anton | 1.23 | |
| 87 : | anton | 1.1 | #include <limits.h> |
| 88 : | |||
| 89 : | #if defined(NeXT) | ||
| 90 : | # include <libc.h> | ||
| 91 : | #endif /* NeXT */ | ||
| 92 : | |||
| 93 : | /* symbol indexed constants */ | ||
| 94 : | |||
| 95 : | #define DOCOL 0 | ||
| 96 : | #define DOCON 1 | ||
| 97 : | #define DOVAR 2 | ||
| 98 : | #define DOUSER 3 | ||
| 99 : | #define DODEFER 4 | ||
| 100 : | #define DOFIELD 5 | ||
| 101 : | pazsan | 1.86 | #define DOVAL 6 |
| 102 : | #define DODOES 7 | ||
| 103 : | #define DOESJUMP 8 | ||
| 104 : | anton | 1.1 | |
| 105 : | /* the size of the DOESJUMP, which resides between DOES> and the does-code */ | ||
| 106 : | #define DOES_HANDLER_SIZE (2*sizeof(Cell)) | ||
| 107 : | |||
| 108 : | jwilke | 1.6 | #include "machine.h" |
| 109 : | anton | 1.1 | |
| 110 : | pazsan | 1.68 | /* C interface data types */ |
| 111 : | |||
| 112 : | typedef WYDE_TYPE Wyde; | ||
| 113 : | typedef TETRABYTE_TYPE Tetrabyte; | ||
| 114 : | typedef unsigned WYDE_TYPE UWyde; | ||
| 115 : | typedef unsigned TETRABYTE_TYPE UTetrabyte; | ||
| 116 : | |||
| 117 : | anton | 1.1 | /* Forth data types */ |
| 118 : | /* Cell and UCell must be the same size as a pointer */ | ||
| 119 : | #define CELL_BITS (sizeof(Cell) * CHAR_BIT) | ||
| 120 : | anton | 1.77 | #define CELL_MIN (((Cell)1)<<(sizeof(Cell)*CHAR_BIT-1)) |
| 121 : | anton | 1.78 | |
| 122 : | #define HALFCELL_BITS (CELL_BITS/2) | ||
| 123 : | #define HALFCELL_MASK ((~(UCell)0)>>HALFCELL_BITS) | ||
| 124 : | #define UH(x) (((UCell)(x))>>HALFCELL_BITS) | ||
| 125 : | #define LH(x) ((x)&HALFCELL_MASK) | ||
| 126 : | #define L2U(x) (((UCell)(x))<<HALFCELL_BITS) | ||
| 127 : | #define HIGHBIT(x) (((UCell)(x))>>(CELL_BITS-1)) | ||
| 128 : | |||
| 129 : | anton | 1.1 | #define FLAG(b) (-(b)) |
| 130 : | #define FILEIO(error) (FLAG(error) & -37) | ||
| 131 : | #define FILEEXIST(error) (FLAG(error) & -38) | ||
| 132 : | |||
| 133 : | #define F_TRUE (FLAG(0==0)) | ||
| 134 : | #define F_FALSE (FLAG(0!=0)) | ||
| 135 : | |||
| 136 : | pazsan | 1.65 | /* define this false if you want native division */ |
| 137 : | pazsan | 1.66 | #ifdef FORCE_CDIV |
| 138 : | #define FLOORED_DIV 0 | ||
| 139 : | #else | ||
| 140 : | pazsan | 1.65 | #define FLOORED_DIV ((1%-3)>0) |
| 141 : | pazsan | 1.66 | #endif |
| 142 : | pazsan | 1.65 | |
| 143 : | anton | 1.93 | #if defined(BUGGY_LONG_LONG) |
| 144 : | pazsan | 1.64 | |
| 145 : | #define BUGGY_LL_CMP /* compares not possible */ | ||
| 146 : | #define BUGGY_LL_MUL /* multiplication not possible */ | ||
| 147 : | #define BUGGY_LL_DIV /* division not possible */ | ||
| 148 : | #define BUGGY_LL_ADD /* addition not possible */ | ||
| 149 : | #define BUGGY_LL_SHIFT /* shift not possible */ | ||
| 150 : | #define BUGGY_LL_D2F /* to float not possible */ | ||
| 151 : | #define BUGGY_LL_F2D /* from float not possible */ | ||
| 152 : | #define BUGGY_LL_SIZE /* long long "too short", so we use something else */ | ||
| 153 : | |||
| 154 : | anton | 1.1 | typedef struct { |
| 155 : | Cell hi; | ||
| 156 : | UCell lo; | ||
| 157 : | } DCell; | ||
| 158 : | |||
| 159 : | typedef struct { | ||
| 160 : | UCell hi; | ||
| 161 : | UCell lo; | ||
| 162 : | } UDCell; | ||
| 163 : | |||
| 164 : | pazsan | 1.64 | #define DHI(x) (x).hi |
| 165 : | #define DLO(x) (x).lo | ||
| 166 : | #define DHI_IS(x,y) (x).hi=(y) | ||
| 167 : | #define DLO_IS(x,y) (x).lo=(y) | ||
| 168 : | |||
| 169 : | anton | 1.78 | #define UD2D(ud) ({UDCell _ud=(ud); (DCell){_ud.hi,_ud.lo};}) |
| 170 : | anton | 1.80 | #define D2UD(d) ({DCell _d1=(d); (UDCell){_d1.hi,_d1.lo};}) |
| 171 : | |||
| 172 : | /* shifts by less than CELL_BITS */ | ||
| 173 : | anton | 1.104 | #define DLSHIFT(d,u) ({DCell _d=(d); UCell _u=(u); \ |
| 174 : | ((_u==0) ? \ | ||
| 175 : | _d : \ | ||
| 176 : | (DCell){(_d.hi<<_u)|(_d.lo>>(CELL_BITS-_u)), \ | ||
| 177 : | _d.lo<<_u});}) | ||
| 178 : | |||
| 179 : | anton | 1.80 | #define UDLSHIFT(ud,u) D2UD(DLSHIFT(UD2D(ud),u)) |
| 180 : | anton | 1.78 | |
| 181 : | anton | 1.39 | #if SMALL_OFF_T |
| 182 : | #define OFF2UD(o) ({UDCell _ud; _ud.hi=0; _ud.lo=(Cell)(o); _ud;}) | ||
| 183 : | #define UD2OFF(ud) ((ud).lo) | ||
| 184 : | #else /* !SMALL_OFF_T */ | ||
| 185 : | #define OFF2UD(o) ({UDCell _ud; off_t _o=(o); _ud.hi=_o>>CELL_BITS; _ud.lo=(Cell)_o; _ud;}) | ||
| 186 : | anton | 1.36 | #define UD2OFF(ud) ({UDCell _ud=(ud); (((off_t)_ud.hi)<<CELL_BITS)+_ud.lo;}) |
| 187 : | anton | 1.39 | #endif /* !SMALL_OFF_T */ |
| 188 : | anton | 1.1 | #define DZERO ((DCell){0,0}) |
| 189 : | |||
| 190 : | anton | 1.93 | #else /* !defined(BUGGY_LONG_LONG) */ |
| 191 : | anton | 1.1 | |
| 192 : | /* DCell and UDCell must be twice as large as Cell */ | ||
| 193 : | typedef DOUBLE_CELL_TYPE DCell; | ||
| 194 : | pazsan | 1.63 | typedef DOUBLE_UCELL_TYPE UDCell; |
| 195 : | anton | 1.1 | |
| 196 : | anton | 1.93 | #define DHI(x) ({ Double_Store _d; _d.d=(x); _d.cells.high; }) |
| 197 : | #define DLO(x) ({ Double_Store _d; _d.d=(x); _d.cells.low; }) | ||
| 198 : | |||
| 199 : | /* beware with the assignment: x is referenced twice! */ | ||
| 200 : | #define DHI_IS(x,y) ({ Double_Store _d; _d.d=(x); _d.cells.high=(y); (x)=_d.d; }) | ||
| 201 : | #define DLO_IS(x,y) ({ Double_Store _d; _d.d=(x); _d.cells.low =(y); (x)=_d.d; }) | ||
| 202 : | |||
| 203 : | #define UD2D(ud) ((DCell)(ud)) | ||
| 204 : | #define D2UD(d) ((UDCell)(d)) | ||
| 205 : | anton | 1.36 | #define OFF2UD(o) ((UDCell)(o)) |
| 206 : | #define UD2OFF(ud) ((off_t)(ud)) | ||
| 207 : | anton | 1.16 | #define DZERO ((DCell)0) |
| 208 : | anton | 1.80 | /* shifts by less than CELL_BITS */ |
| 209 : | #define DLSHIFT(d,u) ((d)<<(u)) | ||
| 210 : | #define UDLSHIFT(d,u) ((d)<<(u)) | ||
| 211 : | anton | 1.16 | |
| 212 : | anton | 1.93 | #endif /* !defined(BUGGY_LONG_LONG) */ |
| 213 : | anton | 1.16 | |
| 214 : | anton | 1.1 | typedef union { |
| 215 : | struct { | ||
| 216 : | anton | 1.16 | #if defined(WORDS_BIGENDIAN)||defined(BUGGY_LONG_LONG) |
| 217 : | anton | 1.1 | Cell high; |
| 218 : | UCell low; | ||
| 219 : | #else | ||
| 220 : | UCell low; | ||
| 221 : | Cell high; | ||
| 222 : | crook | 1.20 | #endif |
| 223 : | anton | 1.1 | } cells; |
| 224 : | anton | 1.16 | DCell d; |
| 225 : | UDCell ud; | ||
| 226 : | anton | 1.1 | } Double_Store; |
| 227 : | pazsan | 1.64 | |
| 228 : | anton | 1.16 | #define FETCH_DCELL_T(d_,lo,hi,t_) ({ \ |
| 229 : | anton | 1.1 | Double_Store _d; \ |
| 230 : | _d.cells.low = (lo); \ | ||
| 231 : | _d.cells.high = (hi); \ | ||
| 232 : | anton | 1.16 | (d_) = _d.t_; \ |
| 233 : | anton | 1.1 | }) |
| 234 : | |||
| 235 : | anton | 1.16 | #define STORE_DCELL_T(d_,lo,hi,t_) ({ \ |
| 236 : | anton | 1.1 | Double_Store _d; \ |
| 237 : | anton | 1.16 | _d.t_ = (d_); \ |
| 238 : | anton | 1.1 | (lo) = _d.cells.low; \ |
| 239 : | (hi) = _d.cells.high; \ | ||
| 240 : | }) | ||
| 241 : | |||
| 242 : | anton | 1.28 | #define vm_twoCell2d(lo,hi,d_) FETCH_DCELL_T(d_,lo,hi,d); |
| 243 : | #define vm_twoCell2ud(lo,hi,d_) FETCH_DCELL_T(d_,lo,hi,ud); | ||
| 244 : | anton | 1.1 | |
| 245 : | anton | 1.28 | #define vm_d2twoCell(d_,lo,hi) STORE_DCELL_T(d_,lo,hi,d); |
| 246 : | #define vm_ud2twoCell(d_,lo,hi) STORE_DCELL_T(d_,lo,hi,ud); | ||
| 247 : | anton | 1.1 | |
| 248 : | typedef Label *Xt; | ||
| 249 : | |||
| 250 : | /* PFA gives the parameter field address corresponding to a cfa */ | ||
| 251 : | #define PFA(cfa) (((Cell *)cfa)+2) | ||
| 252 : | /* PFA1 is a special version for use just after a NEXT1 */ | ||
| 253 : | #define PFA1(cfa) PFA(cfa) | ||
| 254 : | /* CODE_ADDRESS is the address of the code jumped to through the code field */ | ||
| 255 : | #define CODE_ADDRESS(cfa) (*(Xt)(cfa)) | ||
| 256 : | |||
| 257 : | /* DOES_CODE is the Forth code does jumps to */ | ||
| 258 : | #if !defined(DOUBLY_INDIRECT) | ||
| 259 : | # define DOES_CA (symbols[DODOES]) | ||
| 260 : | #else /* defined(DOUBLY_INDIRECT) */ | ||
| 261 : | anton | 1.24 | # define DOES_CA ((Label)&xts[DODOES]) |
| 262 : | anton | 1.1 | #endif /* defined(DOUBLY_INDIRECT) */ |
| 263 : | |||
| 264 : | |||
| 265 : | |||
| 266 : | #define DOES_CODE1(cfa) ((Xt *)(cfa[1])) | ||
| 267 : | /* MAKE_CF creates an appropriate code field at the cfa; | ||
| 268 : | ca is the code address */ | ||
| 269 : | #define MAKE_CF(cfa,ca) ((*(Label *)(cfa)) = ((Label)ca)) | ||
| 270 : | /* make a code field for a defining-word-defined word */ | ||
| 271 : | #define MAKE_DOES_CF(cfa,does_code) ({MAKE_CF(cfa,DOES_CA); \ | ||
| 272 : | ((Cell *)cfa)[1] = (Cell)(does_code);}) | ||
| 273 : | |||
| 274 : | #define CF(const) (-const-2) | ||
| 275 : | |||
| 276 : | #define CF_NIL -1 | ||
| 277 : | |||
| 278 : | #ifndef FLUSH_ICACHE | ||
| 279 : | #warning flush-icache probably will not work (see manual) | ||
| 280 : | # define FLUSH_ICACHE(addr,size) | ||
| 281 : | anton | 1.45 | #warning no FLUSH_ICACHE, turning off dynamic native code by default |
| 282 : | #undef NO_DYNAMIC_DEFAULT | ||
| 283 : | #define NO_DYNAMIC_DEFAULT 1 | ||
| 284 : | anton | 1.1 | #endif |
| 285 : | |||
| 286 : | anton | 1.67 | #if defined(GFORTH_DEBUGGING) || defined(INDIRECT_THREADED) || defined(DOUBLY_INDIRECT) || defined(VM_PROFILING) |
| 287 : | #define STACK_CACHE_DEFAULT 0 | ||
| 288 : | anton | 1.1 | #else |
| 289 : | anton | 1.67 | #define STACK_CACHE_DEFAULT STACK_CACHE_DEFAULT_FAST |
| 290 : | anton | 1.1 | #endif |
| 291 : | |||
| 292 : | #ifdef USE_FTOS | ||
| 293 : | anton | 1.14 | #define IF_fpTOS(x) x |
| 294 : | anton | 1.1 | #else |
| 295 : | anton | 1.14 | #define IF_fpTOS(x) |
| 296 : | #define fpTOS (fp[0]) | ||
| 297 : | anton | 1.1 | #endif |
| 298 : | |||
| 299 : | anton | 1.15 | #define IF_rpTOS(x) |
| 300 : | #define rpTOS (rp[0]) | ||
| 301 : | |||
| 302 : | anton | 1.10 | typedef struct { |
| 303 : | Address base; /* base address of image (0 if relocatable) */ | ||
| 304 : | UCell checksum; /* checksum of ca's to protect against some | ||
| 305 : | incompatible binary/executable combinations | ||
| 306 : | (0 if relocatable) */ | ||
| 307 : | UCell image_size; /* all sizes in bytes */ | ||
| 308 : | UCell dict_size; | ||
| 309 : | UCell data_stack_size; | ||
| 310 : | UCell fp_stack_size; | ||
| 311 : | UCell return_stack_size; | ||
| 312 : | UCell locals_stack_size; | ||
| 313 : | Xt *boot_entry; /* initial ip for booting (in BOOT) */ | ||
| 314 : | Xt *throw_entry; /* ip after signal (in THROW) */ | ||
| 315 : | Cell unused1; /* possibly tib stack size */ | ||
| 316 : | anton | 1.24 | Label *xt_base; /* base of DOUBLE_INDIRECT xts[], for comp-i.fs */ |
| 317 : | anton | 1.10 | Address data_stack_base; /* this and the following fields are initialized by the loader */ |
| 318 : | Address fp_stack_base; | ||
| 319 : | Address return_stack_base; | ||
| 320 : | Address locals_stack_base; | ||
| 321 : | } ImageHeader; | ||
| 322 : | /* the image-header is created in main.fs */ | ||
| 323 : | |||
| 324 : | pazsan | 1.82 | #ifdef HAS_F83HEADERSTRING |
| 325 : | struct F83Name { | ||
| 326 : | struct F83Name *next; /* the link field for old hands */ | ||
| 327 : | char countetc; | ||
| 328 : | char name[0]; | ||
| 329 : | }; | ||
| 330 : | |||
| 331 : | #define F83NAME_COUNT(np) ((np)->countetc & 0x1f) | ||
| 332 : | #endif | ||
| 333 : | anton | 1.48 | struct Longname { |
| 334 : | struct Longname *next; /* the link field for old hands */ | ||
| 335 : | Cell countetc; | ||
| 336 : | char name[0]; | ||
| 337 : | }; | ||
| 338 : | |||
| 339 : | #define LONGNAME_COUNT(np) ((np)->countetc & (((~((UCell)0))<<3)>>3)) | ||
| 340 : | |||
| 341 : | struct Cellpair { | ||
| 342 : | Cell n1; | ||
| 343 : | Cell n2; | ||
| 344 : | }; | ||
| 345 : | |||
| 346 : | struct Cellquad { | ||
| 347 : | Cell n1; | ||
| 348 : | Cell n2; | ||
| 349 : | Cell n3; | ||
| 350 : | Cell n4; | ||
| 351 : | }; | ||
| 352 : | anton | 1.49 | |
| 353 : | #define IOR(flag) ((flag)? -512-errno : 0) | ||
| 354 : | anton | 1.48 | |
| 355 : | anton | 1.91 | #ifdef GFORTH_DEBUGGING |
| 356 : | #if defined(GLOBALS_NONRELOC) | ||
| 357 : | /* if globals cause non-relocatable primitives, keep saved_ip and rp | ||
| 358 : | in a structure and access it through locals */ | ||
| 359 : | typedef struct saved_regs { | ||
| 360 : | Xt *sr_saved_ip; | ||
| 361 : | Cell *sr_rp; | ||
| 362 : | } saved_regs; | ||
| 363 : | extern saved_regs saved_regs_v, *saved_regs_p; | ||
| 364 : | #define saved_ip (saved_regs_p->sr_saved_ip) | ||
| 365 : | #define rp (saved_regs_p->sr_rp) | ||
| 366 : | /* for use in gforth_engine header */ | ||
| 367 : | anton | 1.94 | #error sr_proto not passed in fflib.fs callbacks (solution: disable GLOBALS_NONRELOC) |
| 368 : | anton | 1.92 | #define sr_proto , struct saved_regs *saved_regs_p0 |
| 369 : | anton | 1.91 | #define sr_call , saved_regs_p |
| 370 : | #else /* !defined(GLOBALS_NONRELOC) */ | ||
| 371 : | extern Xt *saved_ip; | ||
| 372 : | extern Cell *rp; | ||
| 373 : | #define sr_proto | ||
| 374 : | #define sr_call | ||
| 375 : | #endif /* !defined(GLOBALS_NONRELOC) */ | ||
| 376 : | #else /* !defined(GFORTH_DEBUGGING) */ | ||
| 377 : | #define sr_proto | ||
| 378 : | #define sr_call | ||
| 379 : | #endif /* !defined(GFORTH_DEBUGGING) */ | ||
| 380 : | |||
| 381 : | Label *gforth_engine(Xt *ip, Cell *sp, Cell *rp0, Float *fp, Address lp sr_proto); | ||
| 382 : | Label *gforth_engine2(Xt *ip, Cell *sp, Cell *rp0, Float *fp, Address lp sr_proto); | ||
| 383 : | Label *gforth_engine3(Xt *ip, Cell *sp, Cell *rp0, Float *fp, Address lp sr_proto); | ||
| 384 : | anton | 1.48 | |
| 385 : | /* engine/prim support routines */ | ||
| 386 : | pazsan | 1.71 | Address gforth_alloc(Cell size); |
| 387 : | anton | 1.35 | char *cstr(Char *from, UCell size, int clear); |
| 388 : | anton | 1.11 | char *tilde_cstr(Char *from, UCell size, int clear); |
| 389 : | anton | 1.85 | Cell opencreate_file(char *s, Cell wfam, int flags, Cell *wiorp); |
| 390 : | anton | 1.35 | DCell timeval2us(struct timeval *tvp); |
| 391 : | anton | 1.48 | void cmove(Char *c_from, Char *c_to, UCell u); |
| 392 : | void cmove_up(Char *c_from, Char *c_to, UCell u); | ||
| 393 : | Cell compare(Char *c_addr1, UCell u1, Char *c_addr2, UCell u2); | ||
| 394 : | struct Longname *listlfind(Char *c_addr, UCell u, struct Longname *longname1); | ||
| 395 : | struct Longname *hashlfind(Char *c_addr, UCell u, Cell *a_addr); | ||
| 396 : | struct Longname *tablelfind(Char *c_addr, UCell u, Cell *a_addr); | ||
| 397 : | UCell hashkey1(Char *c_addr, UCell u, UCell ubits); | ||
| 398 : | struct Cellpair parse_white(Char *c_addr1, UCell u1); | ||
| 399 : | Cell rename_file(Char *c_addr1, UCell u1, Char *c_addr2, UCell u2); | ||
| 400 : | anton | 1.105 | struct Cellquad read_line(Char *c_addr, UCell u1, FILE *wfileid); |
| 401 : | anton | 1.48 | struct Cellpair file_status(Char *c_addr, UCell u); |
| 402 : | anton | 1.91 | Cell to_float(Char *c_addr, UCell u, Float *r_p); |
| 403 : | anton | 1.48 | Float v_star(Float *f_addr1, Cell nstride1, Float *f_addr2, Cell nstride2, UCell ucount); |
| 404 : | void faxpy(Float ra, Float *f_x, Cell nstridex, Float *f_y, Cell nstridey, UCell ucount); | ||
| 405 : | pazsan | 1.60 | UCell lshift(UCell u1, UCell n); |
| 406 : | UCell rshift(UCell u1, UCell n); | ||
| 407 : | anton | 1.61 | int gforth_system(Char *c_addr, UCell u); |
| 408 : | anton | 1.83 | void gforth_ms(UCell u); |
| 409 : | pazsan | 1.102 | UCell gforth_dlopen(Char *c_addr, UCell u); |
| 410 : | pazsan | 1.72 | Cell capscompare(Char *c_addr1, UCell u1, Char *c_addr2, UCell u2); |
| 411 : | anton | 1.105 | int gf_ungetc(int c, FILE *stream); |
| 412 : | void gf_regetc(FILE *stream); | ||
| 413 : | int gf_ungottenc(FILE *stream); | ||
| 414 : | anton | 1.1 | |
| 415 : | anton | 1.50 | /* signal handler stuff */ |
| 416 : | void install_signal_handlers(void); | ||
| 417 : | anton | 1.75 | void throw(int code); |
| 418 : | anton | 1.76 | /* throw codes */ |
| 419 : | #define BALL_DIVZERO -10 | ||
| 420 : | #define BALL_RESULTRANGE -11 | ||
| 421 : | |||
| 422 : | anton | 1.50 | typedef void Sigfunc(int); |
| 423 : | Sigfunc *bsd_signal(int signo, Sigfunc *func); | ||
| 424 : | |||
| 425 : | anton | 1.1 | /* dblsub routines */ |
| 426 : | DCell dnegate(DCell d1); | ||
| 427 : | UDCell ummul (UCell a, UCell b); | ||
| 428 : | DCell mmul (Cell a, Cell b); | ||
| 429 : | UDCell umdiv (UDCell u, UCell v); | ||
| 430 : | DCell smdiv (DCell num, Cell denom); | ||
| 431 : | DCell fmdiv (DCell num, Cell denom); | ||
| 432 : | |||
| 433 : | pazsan | 1.7 | Cell memcasecmp(const Char *s1, const Char *s2, Cell n); |
| 434 : | anton | 1.1 | |
| 435 : | anton | 1.18 | void vm_print_profile(FILE *file); |
| 436 : | void vm_count_block(Xt *ip); | ||
| 437 : | anton | 1.17 | |
| 438 : | anton | 1.22 | /* dynamic superinstruction stuff */ |
| 439 : | anton | 1.33 | void compile_prim1(Cell *start); |
| 440 : | void finish_code(void); | ||
| 441 : | anton | 1.34 | int forget_dyncode(Address code); |
| 442 : | Label decompile_code(Label prim); | ||
| 443 : | anton | 1.17 | |
| 444 : | anton | 1.1 | extern int offset_image; |
| 445 : | anton | 1.5 | extern int die_on_signal; |
| 446 : | anton | 1.74 | extern int ignore_async_signals; |
| 447 : | anton | 1.10 | extern UCell pagesize; |
| 448 : | extern ImageHeader *gforth_header; | ||
| 449 : | anton | 1.19 | extern Label *vm_prims; |
| 450 : | anton | 1.24 | extern Label *xts; |
| 451 : | anton | 1.25 | extern Cell npriminfos; |
| 452 : | pazsan | 1.2 | |
| 453 : | anton | 1.31 | #ifdef HAS_DEBUG |
| 454 : | extern int debug; | ||
| 455 : | #else | ||
| 456 : | # define debug 0 | ||
| 457 : | #endif | ||
| 458 : | |||
| 459 : | pazsan | 1.71 | extern Cell *gforth_SP; |
| 460 : | pazsan | 1.100 | extern Cell *gforth_RP; |
| 461 : | extern Address gforth_LP; | ||
| 462 : | pazsan | 1.71 | extern Float *gforth_FP; |
| 463 : | extern Address gforth_UP; | ||
| 464 : | pazsan | 1.101 | #ifndef HAS_LINKBACK |
| 465 : | extern void * gforth_pointers[]; | ||
| 466 : | #endif | ||
| 467 : | anton | 1.35 | |
| 468 : | pazsan | 1.53 | #ifdef HAS_FFCALL |
| 469 : | pazsan | 1.71 | extern Cell *gforth_RP; |
| 470 : | extern Address gforth_LP; | ||
| 471 : | extern void gforth_callback(Xt* fcall, void * alist); | ||
| 472 : | pazsan | 1.53 | #endif |
| 473 : | |||
| 474 : | anton | 1.35 | #ifdef NO_IP |
| 475 : | extern Label next_code; | ||
| 476 : | #endif | ||
| 477 : | |||
| 478 : | #ifdef HAS_FILE | ||
| 479 : | extern char* fileattr[6]; | ||
| 480 : | extern char* pfileattr[6]; | ||
| 481 : | extern int ufileattr[6]; | ||
| 482 : | anton | 1.9 | #endif |
| 483 : | |||
| 484 : | anton | 1.27 | #ifdef PRINT_SUPER_LENGTHS |
| 485 : | Cell prim_length(Cell prim); | ||
| 486 : | void print_super_lengths(); | ||
| 487 : | #endif | ||
| 488 : | anton | 1.9 | |
| 489 : | pazsan | 1.2 | /* declare all the functions that are missing */ |
| 490 : | #ifndef HAVE_ATANH | ||
| 491 : | extern double atanh(double r1); | ||
| 492 : | extern double asinh(double r1); | ||
| 493 : | extern double acosh(double r1); | ||
| 494 : | #endif | ||
| 495 : | #ifndef HAVE_ECVT | ||
| 496 : | anton | 1.4 | /* extern char* ecvt(double x, int len, int* exp, int* sign);*/ |
| 497 : | pazsan | 1.2 | #endif |
| 498 : | #ifndef HAVE_MEMMOVE | ||
| 499 : | anton | 1.3 | /* extern char *memmove(char *dest, const char *src, long n); */ |
| 500 : | pazsan | 1.2 | #endif |
| 501 : | #ifndef HAVE_POW10 | ||
| 502 : | extern double pow10(double x); | ||
| 503 : | #endif | ||
| 504 : | #ifndef HAVE_STRERROR | ||
| 505 : | extern char *strerror(int err); | ||
| 506 : | #endif | ||
| 507 : | #ifndef HAVE_STRSIGNAL | ||
| 508 : | extern char *strsignal(int sig); | ||
| 509 : | #endif | ||
| 510 : | #ifndef HAVE_STRTOUL | ||
| 511 : | anton | 1.3 | extern unsigned long int strtoul(const char *nptr, char **endptr, int base); |
| 512 : | pazsan | 1.2 | #endif |
| 513 : | |||
| 514 : | pazsan | 1.37 | #define GROUP(x, n) |
| 515 : | pazsan | 1.53 | #define GROUPADD(n) |
|
CVS Admin Powered by ViewCVS 1.0-dev |
ViewCVS and CVS Help |