![[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 [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to vmsmap.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / 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 distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU Emacs General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU Emacs, but only under the conditions described in the
15: GNU Emacs General Public License. A copy of this license is
16: supposed to have been given to you along with GNU Emacs so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21: /* Written by Mukesh Prasad. */
22:
23: #ifdef VMS
24:
25: #include "config.h"
26: #include "lisp.h"
27: #include <rab.h>
28: #include <fab.h>
29: #include <rmsdef.h>
30: #include <secdef.h>
31:
32: /* RMS block size */
33: #define BLOCKSIZE 512
34:
35: /* Maximum number of bytes to be written in one RMS write.
36: * Must be a multiple of BLOCKSIZE.
37: */
38: #define MAXWRITE (BLOCKSIZE * 30)
39:
40: /* This funniness is to ensure that sdata occurs alphabetically BEFORE the
41: $DATA psect and that edata occurs after ALL Emacs psects. This is
42: because the VMS linker sorts all psects in a cluster alphabetically
43: during the linking, unless you use the cluster_psect command. Emacs
44: uses the cluster command to group all Emacs psects into one cluster;
45: this keeps the dumped data separate from any loaded libraries. */
46:
47: globaldef {"$D$ATA"} char sdata[512]; /* Start of saved data area */
48: globaldef {"__DATA"} char edata[512]; /* End of saved data area */
49:
50: /* Structure to write into first block of map file.
51: */
52:
53: struct map_data
54: {
55: char * sdata; /* Start of data area */
56: char * edata; /* End of data area */
57: int datablk; /* Block in file to map data area from/to */
58: };
59:
60: static void fill_fab (), fill_rab ();
61: static int write_data ();
62:
63: extern char *start_of_data ();
64: extern int vms_out_initial; /* Defined in malloc.c */
65:
66: /* Maps in the data and alloc area from the map file.
67: */
68:
69: int
70: mapin_data (name)
71: char * name;
72: {
73: struct FAB fab;
74: struct RAB rab;
75: int status, size;
76: int inadr[2];
77: struct map_data map_data;
78:
79: /* Open map file. */
80: fab = cc$rms_fab;
81: fab.fab$b_fac = FAB$M_BIO|FAB$M_GET;
82: fab.fab$l_fna = name;
83: fab.fab$b_fns = strlen (name);
84: status = sys$open (&fab);
85: if (status != RMS$_NORMAL)
86: {
87: printf ("Map file not available, running bare Emacs....\n");
88: return 0; /* Map file not available */
89: }
90: /* Connect the RAB block */
91: rab = cc$rms_rab;
92: rab.rab$l_fab = &fab;
93: rab.rab$b_rac = RAB$C_SEQ;
94: rab.rab$l_rop = RAB$M_BIO;
95: status = sys$connect (&rab);
96: if (status != RMS$_NORMAL)
97: lib$stop (status);
98: /* Read the header data */
99: rab.rab$l_ubf = &map_data;
100: rab.rab$w_usz = sizeof (map_data);
101: rab.rab$l_bkt = 0;
102: status = sys$read (&rab);
103: if (status != RMS$_NORMAL)
104: lib$stop (status);
105: status = sys$close (&fab);
106: if (status != RMS$_NORMAL)
107: lib$stop (status);
108: if (map_data.sdata != start_of_data ())
109: {
110: printf ("Start of data area has moved: cannot map in data.\n");
111: return 0;
112: }
113: if (map_data.edata != edata)
114: {
115: printf ("End of data area has moved: cannot map in data.\n");
116: return 0;
117: }
118: fab.fab$l_fop |= FAB$M_UFO;
119: status = sys$open (&fab);
120: if (status != RMS$_NORMAL)
121: lib$stop (status);
122: /* Map data area. */
123: inadr[0] = map_data.sdata;
124: inadr[1] = map_data.edata;
125: status = sys$crmpsc (inadr, 0, 0, SEC$M_CRF | SEC$M_WRT, 0, 0, 0,
126: fab.fab$l_stv, 0, map_data.datablk, 0, 0);
127: if (! (status & 1))
128: lib$stop (status);
129: }
130:
131: /* Writes the data and alloc area to the map file.
132: */
133: mapout_data (into)
134: char * into;
135: {
136: struct FAB fab;
137: struct RAB rab;
138: int status;
139: struct map_data map_data;
140: int datasize, msize;
141:
142: if (vms_out_initial)
143: {
144: error ("Out of initial allocation. Must rebuild emacs with more memory (VMS_ALLOCATION_SIZE).");
145: return 0;
146: }
147: map_data.sdata = start_of_data ();
148: map_data.edata = edata;
149: datasize = map_data.edata - map_data.sdata + 1;
150: map_data.datablk = 2 + (sizeof (map_data) + BLOCKSIZE - 1) / BLOCKSIZE;
151: /* Create map file. */
152: fab = cc$rms_fab;
153: fab.fab$b_fac = FAB$M_BIO|FAB$M_PUT;
154: fab.fab$l_fna = into;
155: fab.fab$b_fns = strlen (into);
156: fab.fab$l_fop = FAB$M_CBT;
157: fab.fab$b_org = FAB$C_SEQ;
158: fab.fab$b_rat = 0;
159: fab.fab$b_rfm = FAB$C_VAR;
160: fab.fab$l_alq = 1 + map_data.datablk +
161: ((datasize + BLOCKSIZE - 1) / BLOCKSIZE);
162: status = sys$create (&fab);
163: if (status != RMS$_NORMAL)
164: {
165: error ("Could not create map file");
166: return 0;
167: }
168: /* Connect the RAB block */
169: rab = cc$rms_rab;
170: rab.rab$l_fab = &fab;
171: rab.rab$b_rac = RAB$C_SEQ;
172: rab.rab$l_rop = RAB$M_BIO;
173: status = sys$connect (&rab);
174: if (status != RMS$_NORMAL)
175: {
176: error ("RMS connect to map file failed");
177: return 0;
178: }
179: /* Write the header */
180: rab.rab$l_rbf = &map_data;
181: rab.rab$w_rsz = sizeof (map_data);
182: status = sys$write (&rab);
183: if (status != RMS$_NORMAL)
184: {
185: error ("RMS write (header) to map file failed");
186: return 0;
187: }
188: if (! write_data (&rab, map_data.datablk, map_data.sdata, datasize))
189: return 0;
190: status = sys$close (&fab);
191: if (status != RMS$_NORMAL)
192: {
193: error ("RMS close on map file failed");
194: return 0;
195: }
196: return 1;
197: }
198:
199: static int
200: write_data (rab, firstblock, data, length)
201: struct RAB * rab;
202: char * data;
203: {
204: int status;
205:
206: rab->rab$l_bkt = firstblock;
207: while (length > 0)
208: {
209: rab->rab$l_rbf = data;
210: rab->rab$w_rsz = length > MAXWRITE ? MAXWRITE : length;
211: status = sys$write (rab, 0, 0);
212: if (status != RMS$_NORMAL)
213: {
214: error ("RMS write to map file failed");
215: return 0;
216: }
217: data = &data[MAXWRITE];
218: length -= MAXWRITE;
219: rab->rab$l_bkt = 0;
220: }
221: return 1;
222: } /* write_data */
223:
224: #endif /* VMS */
225:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.