![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmsmap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to vmsmap.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 ! root 1: /* VMS mapping of data and alloc arena for GNU Emacs. ! 2: Copyright (C) 1986, 1987 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU Emacs. ! 5: ! 6: GNU Emacs is free software; you can redistribute it and/or modify ! 7: it under the terms of the GNU General Public License as published by ! 8: the Free Software Foundation; either version 1, or (at your option) ! 9: any later version. ! 10: ! 11: GNU Emacs is distributed in the hope that it will be useful, ! 12: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 14: GNU General Public License for more details. ! 15: ! 16: You should have received a copy of the GNU General Public License ! 17: along with GNU Emacs; see the file COPYING. If not, write to ! 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 19: ! 20: /* Written by Mukesh Prasad. */ ! 21: ! 22: #ifdef VMS ! 23: ! 24: #include "config.h" ! 25: #include "lisp.h" ! 26: #include <rab.h> ! 27: #include <fab.h> ! 28: #include <rmsdef.h> ! 29: #include <secdef.h> ! 30: ! 31: /* RMS block size */ ! 32: #define BLOCKSIZE 512 ! 33: ! 34: /* Maximum number of bytes to be written in one RMS write. ! 35: * Must be a multiple of BLOCKSIZE. ! 36: */ ! 37: #define MAXWRITE (BLOCKSIZE * 30) ! 38: ! 39: /* This funniness is to ensure that sdata occurs alphabetically BEFORE the ! 40: $DATA psect and that edata occurs after ALL Emacs psects. This is ! 41: because the VMS linker sorts all psects in a cluster alphabetically ! 42: during the linking, unless you use the cluster_psect command. Emacs ! 43: uses the cluster command to group all Emacs psects into one cluster; ! 44: this keeps the dumped data separate from any loaded libraries. */ ! 45: ! 46: #ifdef __GNUC__ ! 47: /* We need a large sdata array because otherwise the impure storage will end up ! 48: in low memory, and this will screw up garbage collection (Emacs will not ! 49: be able to tell the difference between a string length and an address). ! 50: This array guarantees that the impure storage is at a sufficiently high ! 51: address so that this problem will not occur. */ ! 52: char sdata[8192] asm("_$$PsectAttributes_NOOVR$$$D$ATA") ; ! 53: char edata[512] asm("_$$PsectAttributes_NOOVR$$__DATA") ; ! 54: #else ! 55: globaldef {"$D$ATA"} char sdata[512]; /* Start of saved data area */ ! 56: globaldef {"__DATA"} char edata[512]; /* End of saved data area */ ! 57: #endif ! 58: ! 59: /* Structure to write into first block of map file. ! 60: */ ! 61: ! 62: struct map_data ! 63: { ! 64: char * sdata; /* Start of data area */ ! 65: char * edata; /* End of data area */ ! 66: int datablk; /* Block in file to map data area from/to */ ! 67: }; ! 68: ! 69: static void fill_fab (), fill_rab (); ! 70: static int write_data (); ! 71: ! 72: extern char *start_of_data (); ! 73: extern int vms_out_initial; /* Defined in malloc.c */ ! 74: ! 75: /* Maps in the data and alloc area from the map file. ! 76: */ ! 77: ! 78: int ! 79: mapin_data (name) ! 80: char * name; ! 81: { ! 82: struct FAB fab; ! 83: struct RAB rab; ! 84: int status, size; ! 85: int inadr[2]; ! 86: struct map_data map_data; ! 87: ! 88: ! 89: /* Open map file. */ ! 90: fab = cc$rms_fab; ! 91: fab.fab$b_fac = FAB$M_BIO|FAB$M_GET; ! 92: fab.fab$l_fna = name; ! 93: fab.fab$b_fns = strlen (name); ! 94: status = sys$open (&fab); ! 95: if (status != RMS$_NORMAL) ! 96: { ! 97: printf ("Map file not available, running bare Emacs....\n"); ! 98: return 0; /* Map file not available */ ! 99: } ! 100: /* Connect the RAB block */ ! 101: rab = cc$rms_rab; ! 102: rab.rab$l_fab = &fab; ! 103: rab.rab$b_rac = RAB$C_SEQ; ! 104: rab.rab$l_rop = RAB$M_BIO; ! 105: status = sys$connect (&rab); ! 106: if (status != RMS$_NORMAL) ! 107: lib$stop (status); ! 108: /* Read the header data */ ! 109: rab.rab$l_ubf = (char *) &map_data; ! 110: rab.rab$w_usz = sizeof (map_data); ! 111: rab.rab$l_bkt = 0; ! 112: status = sys$read (&rab); ! 113: if (status != RMS$_NORMAL) ! 114: lib$stop (status); ! 115: status = sys$close (&fab); ! 116: if (status != RMS$_NORMAL) ! 117: lib$stop (status); ! 118: if (map_data.sdata != start_of_data ()) ! 119: { ! 120: printf ("Start of data area has moved: cannot map in data.\n"); ! 121: return 0; ! 122: } ! 123: if (map_data.edata != edata) ! 124: { ! 125: printf ("End of data area has moved: cannot map in data.\n"); ! 126: return 0; ! 127: } ! 128: fab.fab$l_fop |= FAB$M_UFO; ! 129: status = sys$open (&fab); ! 130: if (status != RMS$_NORMAL) ! 131: lib$stop (status); ! 132: /* Map data area. */ ! 133: inadr[0] = (int) map_data.sdata; ! 134: inadr[1] = (int) map_data.edata; ! 135: status = sys$crmpsc (inadr, 0, 0, SEC$M_CRF | SEC$M_WRT, 0, 0, 0, ! 136: fab.fab$l_stv, 0, map_data.datablk, 0, 0); ! 137: if (! (status & 1)) ! 138: lib$stop (status); ! 139: } ! 140: ! 141: /* Writes the data and alloc area to the map file. ! 142: */ ! 143: mapout_data (into) ! 144: char * into; ! 145: { ! 146: struct FAB fab; ! 147: struct RAB rab; ! 148: int status; ! 149: struct map_data map_data; ! 150: int datasize, msize; ! 151: ! 152: if (vms_out_initial) ! 153: { ! 154: error ("Out of initial allocation. Must rebuild emacs with more memory (VMS_ALLOCATION_SIZE)."); ! 155: return 0; ! 156: } ! 157: map_data.sdata = start_of_data (); ! 158: map_data.edata = edata; ! 159: datasize = map_data.edata - map_data.sdata + 1; ! 160: map_data.datablk = 2 + (sizeof (map_data) + BLOCKSIZE - 1) / BLOCKSIZE; ! 161: /* Create map file. */ ! 162: fab = cc$rms_fab; ! 163: fab.fab$b_fac = FAB$M_BIO|FAB$M_PUT; ! 164: fab.fab$l_fna = into; ! 165: fab.fab$b_fns = strlen (into); ! 166: fab.fab$l_fop = FAB$M_CBT; ! 167: fab.fab$b_org = FAB$C_SEQ; ! 168: fab.fab$b_rat = 0; ! 169: fab.fab$b_rfm = FAB$C_VAR; ! 170: fab.fab$l_alq = 1 + map_data.datablk + ! 171: ((datasize + BLOCKSIZE - 1) / BLOCKSIZE); ! 172: status = sys$create (&fab); ! 173: if (status != RMS$_NORMAL) ! 174: { ! 175: error ("Could not create map file"); ! 176: return 0; ! 177: } ! 178: /* Connect the RAB block */ ! 179: rab = cc$rms_rab; ! 180: rab.rab$l_fab = &fab; ! 181: rab.rab$b_rac = RAB$C_SEQ; ! 182: rab.rab$l_rop = RAB$M_BIO; ! 183: status = sys$connect (&rab); ! 184: if (status != RMS$_NORMAL) ! 185: { ! 186: error ("RMS connect to map file failed"); ! 187: return 0; ! 188: } ! 189: /* Write the header */ ! 190: rab.rab$l_rbf = (char *) &map_data; ! 191: rab.rab$w_rsz = sizeof (map_data); ! 192: status = sys$write (&rab); ! 193: if (status != RMS$_NORMAL) ! 194: { ! 195: error ("RMS write (header) to map file failed"); ! 196: return 0; ! 197: } ! 198: if (! write_data (&rab, map_data.datablk, map_data.sdata, datasize)) ! 199: return 0; ! 200: status = sys$close (&fab); ! 201: if (status != RMS$_NORMAL) ! 202: { ! 203: error ("RMS close on map file failed"); ! 204: return 0; ! 205: } ! 206: return 1; ! 207: } ! 208: ! 209: static int ! 210: write_data (rab, firstblock, data, length) ! 211: struct RAB * rab; ! 212: char * data; ! 213: { ! 214: int status; ! 215: ! 216: rab->rab$l_bkt = firstblock; ! 217: while (length > 0) ! 218: { ! 219: rab->rab$l_rbf = data; ! 220: rab->rab$w_rsz = length > MAXWRITE ? MAXWRITE : length; ! 221: status = sys$write (rab, 0, 0); ! 222: if (status != RMS$_NORMAL) ! 223: { ! 224: error ("RMS write to map file failed"); ! 225: return 0; ! 226: } ! 227: data = &data[MAXWRITE]; ! 228: length -= MAXWRITE; ! 229: rab->rab$l_bkt = 0; ! 230: } ! 231: return 1; ! 232: } /* write_data */ ! 233: ! 234: #endif /* VMS */ ! 235:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.