Subversion Repositories tendra.SVN

Rev

Rev 2 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2 Rev 7
Line -... Line 1...
- 
 
 1 
/*
- 
 
 2 
 * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
- 
 
 3 
 * All rights reserved.
- 
 
 4 
 *
- 
 
 5 
 * Redistribution and use in source and binary forms, with or without
- 
 
 6 
 * modification, are permitted provided that the following conditions are met:
- 
 
 7 
 *
- 
 
 8 
 * 1. Redistributions of source code must retain the above copyright notice,
- 
 
 9 
 *    this list of conditions and the following disclaimer.
- 
 
 10 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
- 
 
 11 
 *    this list of conditions and the following disclaimer in the documentation
- 
 
 12 
 *    and/or other materials provided with the distribution.
- 
 
 13 
 * 3. Neither the name of The TenDRA Project nor the names of its contributors
- 
 
 14 
 *    may be used to endorse or promote products derived from this software
- 
 
 15 
 *    without specific, prior written permission.
- 
 
 16 
 *
- 
 
 17 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
- 
 
 18 
 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- 
 
 19 
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- 
 
 20 
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
- 
 
 21 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- 
 
 22 
 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- 
 
 23 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- 
 
 24 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- 
 
 25 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- 
 
 26 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- 
 
 27 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
 
 28 
 *
- 
 
 29 
 * $Id$
- 
 
 30 
 */
1 
/*
 31 
/*
2 
    		 Crown Copyright (c) 1996
 32 
    		 Crown Copyright (c) 1996
3 
 
 33 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
 34 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
 35 
    owned by the United Kingdom Secretary of State for Defence
Line 27... Line 57...
27 
        it may be put.
 57 
        it may be put.
28 
*/
 58 
*/
29 
/*
 59 
/*
30 
			    VERSION INFORMATION
 60 
			    VERSION INFORMATION
31 
			    ===================
 61 
			    ===================
32 
 
 62 
 
33 
--------------------------------------------------------------------------
 63 
--------------------------------------------------------------------------
34 
$Header: /u/g/release/CVSROOT/Source/src/installers/680x0/common/stab_types.c,v 1.1.1.1 1998/01/17 15:55:50 release Exp $
 64 
$Header: /u/g/release/CVSROOT/Source/src/installers/680x0/common/stab_types.c,v 1.1.1.1 1998/01/17 15:55:50 release Exp $
35 
--------------------------------------------------------------------------
 65 
--------------------------------------------------------------------------
36 
$Log: stab_types.c,v $
 66 
$Log: stab_types.c,v $
37 
 * Revision 1.1.1.1  1998/01/17  15:55:50  release
 67 
 * Revision 1.1.1.1  1998/01/17  15:55:50  release
Line 81... Line 111...
81 
 
 111 
 
82 
/*
 112 
/*
83 
    CREATE A STABS INSTRUCTION
 113 
    CREATE A STABS INSTRUCTION
84 
*/
 114 
*/
85 
 
 115 
 
86 
void make_stabs
 116 
void
87 
    PROTO_N ( ( s, a, b, op ) )
 - 
 
88 
    PROTO_T ( char *s X int a X long b X mach_op *op )
 117 
make_stabs(char *s, int a, long b, mach_op *op)
89 
{
 118 
{
90 
    mach_op *p = make_extern_data ( s, 0 ) ;
 119 
	mach_op *p = make_extern_data(s, 0);
91 
    p->of = make_int_data ( ( long ) a ) ;
 120 
	p->of = make_int_data((long)a);
92 
    p->of->of = make_int_data ( 0 ) ;
 121 
	p->of->of = make_int_data(0);
93 
    p->of->of->of = make_int_data ( b ) ;
 122 
	p->of->of->of = make_int_data(b);
94 
    p->of->of->of->of = ( op ? op : make_int_data ( 0 ) ) ;
 123 
	p->of->of->of->of = (op ? op : make_int_data(0));
95 
    make_instr ( m_stabs, p, null, 0 ) ;
 124 
	make_instr(m_stabs, p, null, 0);
96 
    return ;
 125 
	return;
97 
}
 126 
}
98 
 
 127 
 
99 
 
 128 
 
100 
/*
 129 
/*
101 
    CREATE A STABN INSTRUCTION
 130 
    CREATE A STABN INSTRUCTION
102 
*/
 131 
*/
103 
 
 132 
 
104 
void make_stabn
 133 
void
105 
    PROTO_N ( ( a, lab ) )
 - 
 
106 
    PROTO_T ( int a X long lab )
 134 
make_stabn(int a, long lab)
107 
{
 135 
{
108 
    mach_op *p = make_int_data ( ( long ) a ) ;
 136 
	mach_op *p = make_int_data((long)a);
109 
    p->of = make_int_data ( 0 ) ;
 137 
	p->of = make_int_data(0);
110 
    p->of->of = make_int_data ( 0 ) ;
 138 
	p->of->of = make_int_data(0);
111 
    p->of->of->of = make_lab_data ( lab, 0 ) ;
 139 
	p->of->of->of = make_lab_data(lab, 0);
112 
    make_instr ( m_stabn, p, null, 0 ) ;
 140 
	make_instr(m_stabn, p, null, 0);
113 
    return ;
 141 
	return;
114 
}
 142 
}
115 
 
 143 
 
116 
 
 144 
 
117 
/*
 145 
/*
118 
    TYPE USED FOR BUILDING STAB TYPES
 146 
    TYPE USED FOR BUILDING STAB TYPES
119 
*/
 147 
*/
120 
 
 148 
 
121 
#define TSIZE 100
 149 
#define TSIZE 100
122 
 
 150 
 
123 
typedef struct page_tag {
 151 
typedef struct page_tag {
124 
    int index ;
 152 
	int index;
125 
    char text [ TSIZE ] ;
 153 
	char text[TSIZE];
126 
    struct page_tag *next ;
 154 
	struct page_tag *next;
127 
} page ;
 155 
} page;
128 
 
 156 
 
129 
 
 157 
 
130 
/*
 158 
/*
131 
    LIST OF FREE PAGES
 159 
    LIST OF FREE PAGES
132 
*/
 160 
*/
133 
 
 161 
 
134 
static page *free_pages = null ;
 162 
static page *free_pages = null;
135 
 
 163 
 
136 
 
 164 
 
137 
/*
 165 
/*
138 
    CREATE A NEW PAGE
 166 
    CREATE A NEW PAGE
139 
*/
 167 
*/
140 
 
 168 
 
141 
static page *new_page
 169 
static page *
142 
    PROTO_Z ()
 170 
new_page(void)
143 
{
 171 
{
144 
    page *p = free_pages ;
 172 
	page *p = free_pages;
145 
    if ( p == null ) {
 173 
	if (p == null) {
146 
	p = alloc_nof ( page, 1 ) ;
 174 
		p = alloc_nof(page, 1);
147 
    } else {
 175 
	} else {
148 
	free_pages = p->next ;
 176 
		free_pages = p->next;
149 
    }
 177 
	}
150 
    p->index = 0 ;
 178 
	p->index = 0;
151 
    p->next = null ;
 179 
	p->next = null;
152 
    return ( p ) ;
 180 
	return (p);
153 
}
 181 
}
154 
 
 182 
 
155 
 
 183 
 
156 
/*
 184 
/*
157 
    ADD A STRING TO A PAGE
 185 
    ADD A STRING TO A PAGE
158 
*/
 186 
*/
159 
 
 187 
 
160 
static page *sprint_string
 188 
static page *
161 
    PROTO_N ( ( p, s ) )
 - 
 
162 
    PROTO_T ( page *p X char *s )
 189 
sprint_string(page *p, char *s)
163 
{
 190 
{
164 
    int i = p->index ;
 191 
	int i = p->index;
165 
    for ( ; *s ; s++ ) {
 192 
	for (; *s; s++) {
166 
	if ( i >= TSIZE ) {
 193 
		if (i >= TSIZE) {
167 
	    p->index = TSIZE ;
 194 
			p->index = TSIZE;
168 
	    p->next = new_page () ;
 195 
			p->next = new_page();
169 
	    p = p->next ;
 196 
			p = p->next;
170 
	    i = 0 ;
 197 
			i = 0;
- 
 
 198 
		}
- 
 
 199 
		p->text[i] = *s;
- 
 
 200 
		i++;
171 
	}
 201 
	}
172 
	p->text [i] = *s ;
 - 
 
173 
	i++ ;
 - 
 
174 
    }
 - 
 
175 
    p->index = i ;
 202 
	p->index = i;
176 
    return ( p ) ;
 203 
	return (p);
177 
}
 204 
}
178 
 
 205 
 
179 
 
 206 
 
180 
/*
 207 
/*
181 
    ADD A NUMBER TO A PAGE
 208 
    ADD A NUMBER TO A PAGE
182 
*/
 209 
*/
183 
 
 210 
 
184 
static page *sprint_number
 211 
static page *
185 
    PROTO_N ( ( p, n ) )
 - 
 
186 
    PROTO_T ( page *p X long n )
 212 
sprint_number(page *p, long n)
187 
{
 213 
{
188 
    char buff [100] ;
 214 
	char buff[100];
189 
    ( void ) sprintf ( buff, "%ld", n ) ;
 215 
	(void)sprintf(buff, "%ld", n);
190 
    return ( sprint_string ( p, buff ) ) ;
 216 
	return (sprint_string(p, buff));
191 
}
 217 
}
192 
 
 218 
 
193 
 
 219 
 
194 
/*
 220 
/*
195 
    CREATE A NEW STAB TYPE
 221 
    CREATE A NEW STAB TYPE
196 
*/
 222 
*/
197 
 
 223 
 
198 
static char *new_stab_type
 224 
static char *
199 
    PROTO_N ( ( dt ) )
 - 
 
200 
    PROTO_T ( diag_type dt )
 225 
new_stab_type(diag_type dt)
201 
{
 226 
{
202 
    static long next_stab_type = 16 ;
 227 
	static long next_stab_type = 16;
203 
    char *res = alloc_nof ( char, 8 ) ;
 228 
	char *res = alloc_nof(char, 8);
204 
    sprintf ( res, "%ld", next_stab_type++ ) ;
 229 
	sprintf(res, "%ld", next_stab_type++);
- 
 
 230 
	if (dt) {
205 
    if ( dt ) dt->been_outed = ( OUTPUT_REC ) res ;
 231 
		dt->been_outed = (OUTPUT_REC)res;
- 
 
 232 
	}
206 
    return ( res ) ;
 233 
	return (res);
207 
}
 234 
}
208 
 
 235 
 
209 
 
 236 
 
210 
/*
 237 
/*
211 
    SIZE OF LAST TYPE ANALYSED
 238 
    SIZE OF LAST TYPE ANALYSED
212 
*/
 239 
*/
213 
 
 240 
 
214 
static long last_type_sz = 0 ;
 241 
static long last_type_sz = 0;
215 
 
 242 
 
216 
 
 243 
 
217 
/*
 244 
/*
218 
    INDEX TO SIMPLE STAB TYPES
 245 
    INDEX TO SIMPLE STAB TYPES
219 
*/
 246 
*/
Line 234... Line 261...
234 
 
 261 
 
235 
/*
 262 
/*
236 
    TABLE OF SIMPLE STAB TYPES
 263 
    TABLE OF SIMPLE STAB TYPES
237 
*/
 264 
*/
238 
 
 265 
 
239 
static char *stab_tab [] = {
 266 
static char *stab_tab[] = {
240 
    "2", "11", "6", "8", "1", "4", "12", "13", "14", "15",
 267 
	"2", "11", "6", "8", "1", "4", "12", "13", "14", "15",
241 
    null, null, null, null, null, null, null, null, null, null
 268 
	null, null, null, null, null, null, null, null, null, null
242 
} ;
 269 
};
243 
 
 270 
 
244 
 
 271 
 
245 
/*
 272 
/*
246 
    TEST IF A TYPE IS SIMPLE
 273 
    TEST IF A TYPE IS SIMPLE
247 
*/
 274 
*/
248 
 
 275 
 
249 
static int test_type
 276 
static int
250 
    PROTO_N ( ( dt ) )
 - 
 
251 
    PROTO_T ( diag_type dt )
 277 
test_type(diag_type dt)
252 
{
 278 
{
253 
    switch ( dt->key ) {
 279 
	switch (dt->key) {
254 
 
 - 
 
255 
	case DIAG_TYPE_FLOAT : {
 280 
	case DIAG_TYPE_FLOAT: {
256 
	    shape sha = f_floating ( dt->data.f_var ) ;
 281 
		shape sha = f_floating(dt->data.f_var);
257 
	    last_type_sz = shape_size ( sha ) ;
 282 
		last_type_sz = shape_size(sha);
258 
	    if ( name ( sha ) == shrealhd ) return ( STAB_FLOAT ) ;
 283 
		if (name(sha) == shrealhd) {
- 
 
 284 
			return (STAB_FLOAT);
- 
 
 285 
		}
259 
	    if ( name ( sha ) == realhd ) return ( STAB_DOUBLE ) ;
 286 
		if (name(sha) == realhd) {
260 
	    return ( STAB_LDOUBLE ) ;
 287 
			return (STAB_DOUBLE);
261 
	}
 288 
		}
- 
 
 289 
		return (STAB_LDOUBLE);
262 
 
 290 
	}
263 
	case DIAG_TYPE_VARIETY : {
 291 
	case DIAG_TYPE_VARIETY: {
264 
	    shape sha = f_integer ( dt->data.var ) ;
 292 
		shape sha = f_integer(dt->data.var);
265 
	    last_type_sz = shape_size ( sha ) ;
 293 
		last_type_sz = shape_size(sha);
266 
	    switch ( name ( sha ) ) {
 294 
		switch (name(sha)) {
- 
 
 295 
		case scharhd:
267 
		case scharhd : return ( STAB_SCHAR ) ;
 296 
			return (STAB_SCHAR);
- 
 
 297 
		case swordhd:
268 
		case swordhd : return ( STAB_SWORD ) ;
 298 
			return (STAB_SWORD);
- 
 
 299 
		case slonghd:
269 
		case slonghd : return ( STAB_SLONG ) ;
 300 
			return (STAB_SLONG);
- 
 
 301 
		case ucharhd:
270 
		case ucharhd : return ( STAB_UCHAR ) ;
 302 
			return (STAB_UCHAR);
- 
 
 303 
		case uwordhd:
271 
		case uwordhd : return ( STAB_UWORD ) ;
 304 
			return (STAB_UWORD);
- 
 
 305 
		case ulonghd:
272 
		case ulonghd : return ( STAB_ULONG ) ;
 306 
			return (STAB_ULONG);
273 
	    }
 307 
		}
274 
	    break ;
 308 
		break;
275 
	}
 309 
	}
276 
 
 - 
 
277 
	case DIAG_TYPE_NULL : {
 310 
	case DIAG_TYPE_NULL:
278 
	    last_type_sz = 0 ;
 311 
		last_type_sz = 0;
279 
	    return ( STAB_VOID ) ;
 312 
		return (STAB_VOID);
280 
	}
 - 
 
281 
 
 - 
 
282 
	default : {
 313 
	default:
283 
	    break ;
 314 
		break;
284 
	}
 315 
	}
285 
    }
 - 
 
286 
    return ( STAB_COMPLEX ) ;
 316 
	return (STAB_COMPLEX);
287 
}
 317 
}
288 
 
 318 
 
289 
 
 319 
 
290 
/*
 320 
/*
291 
    BUILD UP A STAB TYPE IN A BUFFER
 321 
    BUILD UP A STAB TYPE IN A BUFFER
292 
*/
 322 
*/
293 
 
 323 
 
294 
static page *build_stab_type
 324 
static page *
295 
    PROTO_N ( ( dt, ptr ) )
 - 
 
296 
    PROTO_T ( diag_type dt X page *ptr )
 325 
build_stab_type(diag_type dt, page *ptr)
297 
{
 326 
{
298 
    switch ( dt->key ) {
 327 
	switch (dt->key) {
299 
 
 - 
 
300 
	case DIAG_TYPE_FLOAT :
 328 
	case DIAG_TYPE_FLOAT:
301 
	case DIAG_TYPE_NULL :
 329 
	case DIAG_TYPE_NULL:
302 
	case DIAG_TYPE_VARIETY : {
 330 
	case DIAG_TYPE_VARIETY: {
303 
	    /* Simple types */
 331 
		/* Simple types */
304 
	    int t = test_type ( dt ) ;
 332 
		int t = test_type(dt);
305 
	    ptr = sprint_string ( ptr, stab_tab [t] ) ;
 333 
		ptr = sprint_string(ptr, stab_tab[t]);
306 
	    break ;
 334 
		break;
307 
	}
 - 
 
308 
 
 - 
 
309 
	case DIAG_TYPE_ARRAY : {
 - 
 
310 
	    diag_type dtl = dt->data.array.element_type ;
 - 
 
311 
	    long lo = no ( dt->data.array.lower_b ) ;
 - 
 
312 
	    long hi = no ( dt->data.array.upper_b ) ;
 - 
 
313 
	    char *stl = analyse_stab_type ( dtl, null, null ) ;
 - 
 
314 
	    ptr = sprint_string ( ptr, new_stab_type ( dt ) ) ;
 - 
 
315 
	    ptr = sprint_string ( ptr, "=ar1;" ) ;
 - 
 
316 
	    ptr = sprint_number ( ptr, lo ) ;
 - 
 
317 
	    ptr = sprint_string ( ptr, ";" ) ;
 - 
 
318 
	    ptr = sprint_number ( ptr, hi ) ;
 - 
 
319 
	    ptr = sprint_string ( ptr, ";" ) ;
 - 
 
320 
	    ptr = sprint_string ( ptr, stl ) ;
 - 
 
321 
	    last_type_sz *= ( hi - lo + 1 ) ;
 - 
 
322 
	    break ;
 - 
 
323 
	}
 - 
 
324 
 
 - 
 
325 
	case DIAG_TYPE_BITFIELD : {
 - 
 
326 
	    long sz = dt->data.bitfield.no_of_bits.nat_val.small_nat ;
 - 
 
327 
	    ptr = sprint_string ( ptr, "1" ) ;
 - 
 
328 
	    last_type_sz = sz ;
 - 
 
329 
	    break ;
 - 
 
330 
	}
 - 
 
331 
 
 - 
 
332 
	case DIAG_TYPE_ENUM : {
 - 
 
333 
	    /* Not yet supported */
 - 
 
334 
	    ptr = sprint_string ( ptr, "1" ) ;
 - 
 
335 
	    last_type_sz = 32 ;
 - 
 
336 
	    break ;
 - 
 
337 
	}
 335 
	}
338 
 
 - 
 
339 
	case DIAG_TYPE_LOC : {
 336 
	case DIAG_TYPE_ARRAY: {
340 
	    diag_type dtl = dt->data.loc.object ;
 337 
		diag_type dtl = dt->data.array.element_type;
- 
 
 338 
		long lo = no(dt->data.array.lower_b);
- 
 
 339 
		long hi = no(dt->data.array.upper_b);
341 
	    ptr = build_stab_type ( dtl, ptr ) ;
 340 
		char *stl = analyse_stab_type(dtl, null, null);
- 
 
 341 
		ptr = sprint_string(ptr, new_stab_type(dt));
- 
 
 342 
		ptr = sprint_string(ptr, "=ar1;");
- 
 
 343 
		ptr = sprint_number(ptr, lo);
- 
 
 344 
		ptr = sprint_string(ptr, ";");
- 
 
 345 
		ptr = sprint_number(ptr, hi);
- 
 
 346 
		ptr = sprint_string(ptr, ";");
- 
 
 347 
		ptr = sprint_string(ptr, stl);
- 
 
 348 
		last_type_sz *= (hi - lo + 1);
342 
	    break ;
 349 
		break;
343 
	}
 350 
	}
- 
 
 351 
	case DIAG_TYPE_BITFIELD: {
- 
 
 352 
		long sz = dt->data.bitfield.no_of_bits.nat_val.small_nat;
- 
 
 353 
		ptr = sprint_string(ptr, "1");
- 
 
 354 
		last_type_sz = sz;
- 
 
 355 
		break;
344 
 
 356 
	}
- 
 
 357 
	case DIAG_TYPE_ENUM:
- 
 
 358 
		/* Not yet supported */
- 
 
 359 
		ptr = sprint_string(ptr, "1");
- 
 
 360 
		last_type_sz = 32;
- 
 
 361 
		break;
- 
 
 362 
	case DIAG_TYPE_LOC: {
- 
 
 363 
		diag_type dtl = dt->data.loc.object;
- 
 
 364 
		ptr = build_stab_type(dtl, ptr);
- 
 
 365 
		break;
- 
 
 366 
	}
345 
	case DIAG_TYPE_PROC : {
 367 
	case DIAG_TYPE_PROC: {
346 
	    diag_type dtl = dt->data.proc.result_type ;
 368 
		diag_type dtl = dt->data.proc.result_type;
347 
	    char *stl = analyse_stab_type ( dtl, null, null ) ;
 369 
		char *stl = analyse_stab_type(dtl, null, null);
348 
	    ptr = sprint_string ( ptr, new_stab_type ( dt ) ) ;
 370 
		ptr = sprint_string(ptr, new_stab_type(dt));
349 
	    ptr = sprint_string ( ptr, "=*" ) ;
 371 
		ptr = sprint_string(ptr, "=*");
350 
	    ptr = sprint_string ( ptr, new_stab_type ( null ) ) ;
 372 
		ptr = sprint_string(ptr, new_stab_type(null));
351 
	    ptr = sprint_string ( ptr, "=f" ) ;
 373 
		ptr = sprint_string(ptr, "=f");
- 
 
 374 
		ptr = sprint_string(ptr, stl);
- 
 
 375 
		last_type_sz = 32;
- 
 
 376 
		break;
- 
 
 377 
	}
- 
 
 378 
	case DIAG_TYPE_PTR: {
- 
 
 379 
		diag_type dtl = dt->data.ptr.object;
- 
 
 380 
		int t = test_type(dtl);
- 
 
 381 
		if (t != STAB_COMPLEX) {
- 
 
 382 
			char *st = stab_tab[STAB_PTR + t];
- 
 
 383 
			if (st) {
- 
 
 384 
				ptr = sprint_string(ptr, st);
- 
 
 385 
			} else {
- 
 
 386 
				st = new_stab_type(null);
- 
 
 387 
				stab_tab[STAB_PTR + t] = st;
- 
 
 388 
				ptr = sprint_string(ptr, st);
- 
 
 389 
				ptr = sprint_string(ptr, "=*");
- 
 
 390 
				ptr = sprint_string(ptr, stab_tab[t]);
- 
 
 391 
			}
- 
 
 392 
		} else {
- 
 
 393 
			char *stl = analyse_stab_type(dtl, null, null);
- 
 
 394 
			ptr = sprint_string(ptr, new_stab_type(dt));
- 
 
 395 
			ptr = sprint_string(ptr, "=*");
352 
	    ptr = sprint_string ( ptr, stl ) ;
 396 
			ptr = sprint_string(ptr, stl);
- 
 
 397 
		}
353 
	    last_type_sz = 32 ;
 398 
		last_type_sz = 32;
354 
	    break ;
 399 
		break;
355 
	}
 400 
	}
356 
 
 - 
 
357 
	case DIAG_TYPE_PTR : {
 401 
	case DIAG_TYPE_STRUCT: {
358 
	    diag_type dtl = dt->data.ptr.object ;
 402 
		char *nm = dt->data.t_struct.nme.ints.chars;
- 
 
 403 
		if (*nm) {
- 
 
 404 
			char *res;
- 
 
 405 
			dt->data.t_struct.nme.ints.chars = "";
359 
	    int t = test_type ( dtl ) ;
 406 
			res = analyse_stab_type(dt, nm, "T");
360 
	    if ( t != STAB_COMPLEX ) {
 407 
			dt->data.t_struct.nme.ints.chars = nm;
361 
		char *st = stab_tab [ STAB_PTR + t ] ;
 408 
			make_stabs(res, 128, L0, null);
362 
		if ( st ) {
 409 
			res = (char *)dt->been_outed;
363 
		    ptr = sprint_string ( ptr, st ) ;
 410 
			ptr = sprint_string(ptr, res);
364 
		} else {
 411 
		} else {
- 
 
 412 
			shape sha = dt->data.t_struct.tdf_shape;
- 
 
 413 
			long sz = shape_size(sha);
- 
 
 414 
#if 0
- 
 
 415 
			struct_fields *fld = dt->data.t_struct.fields->array;
- 
 
 416 
#else
- 
 
 417 
			diag_field *fld = dt->data.t_struct.fields->array;
- 
 
 418 
#endif
- 
 
 419 
			long i, n = (long)dt->data.t_struct.fields->lastused;
- 
 
 420 
 
- 
 
 421 
			ptr = sprint_string(ptr, new_stab_type(dt));
- 
 
 422 
			ptr = sprint_string(ptr, "=s");
- 
 
 423 
			ptr = sprint_number(ptr, sz / 8);
- 
 
 424 
 
- 
 
 425 
			/* Deal with structure fields */
- 
 
 426 
			for (i = n - 1; i >= 0; i--) {
- 
 
 427 
				char *fnm = fld[i] ->field_name.ints.chars;
- 
 
 428 
				long off = no(fld[i] ->where);
- 
 
 429 
				diag_type dtl = fld[i] ->field_type;
365 
		    st = new_stab_type ( null ) ;
 430 
				char *q = analyse_stab_type(dtl, null, null);
- 
 
 431 
				ptr = sprint_string(ptr, fnm);
- 
 
 432 
				ptr = sprint_string(ptr, ":");
366 
		    stab_tab [ STAB_PTR + t ] = st ;
 433 
				ptr = sprint_string(ptr, q);
367 
		    ptr = sprint_string ( ptr, st ) ;
 434 
				ptr = sprint_string(ptr, ",");
- 
 
 435 
				ptr = sprint_number(ptr, off);
368 
		    ptr = sprint_string ( ptr, "=*" ) ;
 436 
				ptr = sprint_string(ptr, ",");
- 
 
 437 
				ptr = sprint_number(ptr, last_type_sz);
369 
		    ptr = sprint_string ( ptr, stab_tab [t] ) ;
 438 
				ptr = sprint_string(ptr, ";");
- 
 
 439 
			}
- 
 
 440 
			ptr = sprint_string(ptr, ";");
- 
 
 441 
			last_type_sz = sz;
370 
		}
 442 
		}
371 
	    } else {
 - 
 
372 
		char *stl = analyse_stab_type ( dtl, null, null ) ;
 - 
 
373 
		ptr = sprint_string ( ptr, new_stab_type ( dt ) ) ;
 - 
 
374 
		ptr = sprint_string ( ptr, "=*" ) ;
 - 
 
375 
		ptr = sprint_string ( ptr, stl ) ;
 - 
 
376 
	    }
 - 
 
377 
	    last_type_sz = 32 ;
 - 
 
378 
	    break ;
 443 
		break;
379 
	}
 444 
	}
380 
 
 - 
 
381 
	case DIAG_TYPE_STRUCT : {
 445 
	case DIAG_TYPE_UNION: {
382 
	    char *nm = dt->data.t_struct.nme.ints.chars ;
 446 
		char *nm = dt->data.t_union.nme.ints.chars;
383 
	    if ( *nm ) {
 447 
		if (*nm) {
384 
		char *res ;
 448 
			char *res;
385 
		dt->data.t_struct.nme.ints.chars = "" ;
 449 
			dt->data.t_struct.nme.ints.chars = "";
386 
		res = analyse_stab_type ( dt, nm, "T" ) ;
 450 
			res = analyse_stab_type(dt, nm, "T");
387 
		dt->data.t_struct.nme.ints.chars = nm ;
 451 
			dt->data.t_struct.nme.ints.chars = nm;
388 
		make_stabs ( res, 128, L0, null ) ;
 452 
			make_stabs(res, 128, L0, null);
389 
		res = ( char * ) dt->been_outed ;
 453 
			res = (char *)dt->been_outed;
390 
		ptr = sprint_string ( ptr, res ) ;
 454 
			ptr = sprint_string(ptr, res);
391 
	    } else {
 455 
		} else {
392 
		shape sha = dt->data.t_struct.tdf_shape ;
 456 
			shape sha = dt->data.t_union.tdf_shape;
393 
		long sz = shape_size ( sha ) ;
 457 
			long sz = shape_size(sha);
394 
#if 0
 458 
#if 0
395 
		struct_fields *fld = dt->data.t_struct.fields->array ;
 459 
			union_fields *fld = dt->data.t_union.fields->array;
396 
#else
 460 
#else
397 
		diag_field *fld = dt->data.t_struct.fields->array ;
 461 
			diag_field *fld = dt->data.t_union.fields->array;
398 
#endif
 462 
#endif
399 
		long i, n = ( long ) dt->data.t_struct.fields->lastused ;
 463 
			long i, n = (long)dt->data.t_union.fields->lastused;
400 
 
 464 
 
401 
		ptr = sprint_string ( ptr, new_stab_type ( dt ) ) ;
 465 
			ptr = sprint_string(ptr, new_stab_type(dt));
402 
		ptr = sprint_string ( ptr, "=s" ) ;
 466 
			ptr = sprint_string(ptr, "=u");
403 
		ptr = sprint_number ( ptr, sz / 8 ) ;
 467 
			ptr = sprint_number(ptr, sz / 8);
404 
 
 468 
 
405 
		/* Deal with structure fields */
 469 
			/* Deal with union fields */
406 
		for ( i = n - 1 ; i >= 0 ; i-- ) {
 470 
			for (i = n - 1; i >= 0; i--) {
407 
		    char *fnm = fld [i]->field_name.ints.chars ;
 471 
				char *fnm = fld[i] ->field_name.ints.chars;
408 
		    long off = no ( fld [i]->where ) ;
 - 
 
409 
		    diag_type dtl = fld [i]->field_type ;
 472 
				diag_type dtl = fld[i] ->field_type;
410 
		    char *q = analyse_stab_type ( dtl, null, null ) ;
 473 
				char *q = analyse_stab_type(dtl, null, null);
411 
		    ptr = sprint_string ( ptr, fnm ) ;
 474 
				ptr = sprint_string(ptr, fnm);
412 
		    ptr = sprint_string ( ptr, ":" ) ;
 475 
				ptr = sprint_string(ptr, ":");
413 
		    ptr = sprint_string ( ptr, q ) ;
 476 
				ptr = sprint_string(ptr, q);
414 
		    ptr = sprint_string ( ptr, "," ) ;
 - 
 
415 
		    ptr = sprint_number ( ptr, off ) ;
 - 
 
416 
		    ptr = sprint_string ( ptr, "," ) ;
 477 
				ptr = sprint_string(ptr, ",0,");
417 
		    ptr = sprint_number ( ptr, last_type_sz ) ;
 478 
				ptr = sprint_number(ptr, last_type_sz);
418 
		    ptr = sprint_string ( ptr, ";" ) ;
 479 
				ptr = sprint_string(ptr, ";");
419 
		}
 480 
			}
420 
		ptr = sprint_string ( ptr, ";" ) ;
 481 
			ptr = sprint_string(ptr, ";");
421 
		last_type_sz = sz ;
 482 
			last_type_sz = sz;
422 
	    }
 - 
 
423 
	    break ;
 - 
 
424 
	}
 - 
 
425 
 
 - 
 
426 
	case DIAG_TYPE_UNION : {
 - 
 
427 
	    char *nm = dt->data.t_union.nme.ints.chars ;
 - 
 
428 
	    if ( *nm ) {
 - 
 
429 
		char *res ;
 - 
 
430 
		dt->data.t_struct.nme.ints.chars = "" ;
 - 
 
431 
		res = analyse_stab_type ( dt, nm, "T" ) ;
 - 
 
432 
		dt->data.t_struct.nme.ints.chars = nm ;
 - 
 
433 
		make_stabs ( res, 128, L0, null ) ;
 - 
 
434 
		res = ( char * ) dt->been_outed ;
 - 
 
435 
		ptr = sprint_string ( ptr, res ) ;
 - 
 
436 
	    } else {
 - 
 
437 
		shape sha = dt->data.t_union.tdf_shape ;
 - 
 
438 
		long sz = shape_size ( sha ) ;
 - 
 
439 
#if 0
 - 
 
440 
		union_fields *fld = dt->data.t_union.fields->array ;
 - 
 
441 
#else
 - 
 
442 
		diag_field *fld = dt->data.t_union.fields->array ;
 - 
 
443 
#endif
 - 
 
444 
		long i, n = ( long ) dt->data.t_union.fields->lastused ;
 - 
 
445 
 
 - 
 
446 
		ptr = sprint_string ( ptr, new_stab_type ( dt ) ) ;
 - 
 
447 
		ptr = sprint_string ( ptr, "=u" ) ;
 - 
 
448 
		ptr = sprint_number ( ptr, sz / 8 ) ;
 - 
 
449 
 
 - 
 
450 
		/* Deal with union fields */
 - 
 
451 
		for ( i = n - 1 ; i >= 0 ; i-- ) {
 - 
 
452 
		    char *fnm = fld [i]->field_name.ints.chars ;
 - 
 
453 
		    diag_type dtl = fld [i]->field_type ;
 - 
 
454 
		    char *q = analyse_stab_type ( dtl, null, null ) ;
 - 
 
455 
		    ptr = sprint_string ( ptr, fnm ) ;
 - 
 
456 
		    ptr = sprint_string ( ptr, ":" ) ;
 - 
 
457 
		    ptr = sprint_string ( ptr, q ) ;
 - 
 
458 
		    ptr = sprint_string ( ptr, ",0," ) ;
 - 
 
459 
		    ptr = sprint_number ( ptr, last_type_sz ) ;
 - 
 
460 
		    ptr = sprint_string ( ptr, ";" ) ;
 - 
 
461 
		}
 483 
		}
- 
 
 484 
		break;
- 
 
 485 
	}
- 
 
 486 
	default:
462 
		ptr = sprint_string ( ptr, ";" ) ;
 487 
		ptr = sprint_string(ptr, "15");
463 
		last_type_sz = sz ;
 488 
		last_type_sz = 0;
- 
 
 489 
		break;
- 
 
 490 
	}
- 
 
 491 
	return (ptr);
- 
 
 492 
}
- 
 
 493 
 
- 
 
 494 
 
- 
 
 495 
/*
- 
 
 496 
    FIND A STAB TYPE
- 
 
 497 
*/
- 
 
 498 
 
464 
	    }
 499 
char *
- 
 
 500 
analyse_stab_type(diag_type dt, char *nm, char *cl)
- 
 
 501 
{
- 
 
 502 
	int n = 0;
- 
 
 503 
	page *ptr, *p;
- 
 
 504 
	char *res = (char *)dt->been_outed;
- 
 
 505 
	if (res && nm == null && cl == null) {
- 
 
 506 
		return (res);
- 
 
 507 
	}
- 
 
 508 
	p = ptr = new_page();
- 
 
 509 
	if (nm) {
- 
 
 510 
		p = sprint_string(p, "\"");
- 
 
 511 
		p = sprint_string(p, nm);
- 
 
 512 
	}
- 
 
 513 
	if (cl) {
- 
 
 514 
		p = sprint_string(p, ":");
- 
 
 515 
		p = sprint_string(p, cl);
- 
 
 516 
	}
465 
	    break ;
 517 
	if (res) {
- 
 
 518 
		p = sprint_string(p, res);
- 
 
 519 
	} else {
- 
 
 520 
		p = build_stab_type(dt, p);
- 
 
 521 
	}
- 
 
 522 
	if (nm) {
- 
 
 523 
		p = sprint_string(p, "\"");
- 
 
 524 
	}
- 
 
 525 
 
- 
 
 526 
	/* Copy accumulated string */
- 
 
 527 
	for (p = ptr; p; p = p->next) {
- 
 
 528 
		n += p->index;
- 
 
 529 
	}
- 
 
 530 
	res = alloc_nof(char, n + 1);
- 
 
 531 
	n = 0;
- 
 
 532 
	for (p = ptr; p; p = p->next) {
- 
 
 533 
		strncpy(res + n, p->text, p->index);
- 
 
 534 
		n += p->index;
466 
	}
 535 
	}
- 
 
 536 
	res[n] = 0;
467 
 
 537 
 
468 
	default : {
 538 
	/* Free pages */
469 
	    ptr = sprint_string ( ptr, "15" ) ;
 539 
	p =  ptr;
470 
	    last_type_sz = 0 ;
 540 
	while (p->next) {
471 
	    break ;
 541 
		p = p->next;
472 
	}
 542 
	}
473 
    }
 - 
 
474 
    return ( ptr ) ;
 - 
 
475 
}
 - 
 
476 
 
 - 
 
477 
 
 - 
 
478 
/*
 - 
 
479 
    FIND A STAB TYPE
 - 
 
480 
*/
 - 
 
481 
 
 - 
 
482 
char *analyse_stab_type
 - 
 
483 
    PROTO_N ( ( dt, nm, cl ) )
 - 
 
484 
    PROTO_T ( diag_type dt X char *nm X char *cl )
 - 
 
485 
{
 - 
 
486 
    int n = 0 ;
 - 
 
487 
    page *ptr, *p ;
 - 
 
488 
    char *res = ( char * ) dt->been_outed ;
 - 
 
489 
    if ( res && nm == null && cl == null ) return ( res ) ;
 - 
 
490 
    p = ptr = new_page () ;
 - 
 
491 
    if ( nm ) {
 - 
 
492 
	p = sprint_string ( p, "\"" ) ;
 - 
 
493 
	p = sprint_string ( p, nm ) ;
 - 
 
494 
    }
 - 
 
495 
    if ( cl ) {
 - 
 
496 
	p = sprint_string ( p, ":" ) ;
 - 
 
497 
	p = sprint_string ( p, cl ) ;
 - 
 
498 
    }
 - 
 
499 
    if ( res ) {
 - 
 
500 
	p = sprint_string ( p, res ) ;
 - 
 
501 
    } else {
 - 
 
502 
	p = build_stab_type ( dt, p ) ;
 - 
 
503 
    }
 - 
 
504 
    if ( nm ) p = sprint_string ( p, "\"" ) ;
 - 
 
505 
 
 - 
 
506 
    /* Copy accumulated string */
 - 
 
507 
    for ( p = ptr ; p ; p = p->next ) n += p->index ;
 - 
 
508 
    res = alloc_nof ( char, n + 1 ) ;
 - 
 
509 
    n = 0 ;
 - 
 
510 
    for ( p = ptr ; p ; p = p->next ) {
 - 
 
511 
	strncpy ( res + n, p->text, p->index ) ;
 - 
 
512 
	n += p->index ;
 - 
 
513 
    }
 - 
 
514 
    res [n] = 0 ;
 - 
 
515 
 
 - 
 
516 
    /* Free pages */
 - 
 
517 
    p =  ptr ;
 - 
 
518 
    while ( p->next ) p = p->next ;
 - 
 
519 
    p->next = free_pages ;
 543 
	p->next = free_pages;
520 
    free_pages = ptr ;
 544 
	free_pages = ptr;
521 
    return ( res ) ;
 545 
	return (res);
522 
}
 546 
}
523 
 
 547 
 
524 
 
 548 
 
525 
/*
 549 
/*
526 
    INITIALIZE BASIC STAB TYPES
 550 
    INITIALIZE BASIC STAB TYPES
527 
*/
 551 
*/
528 
 
 552 
 
529 
void init_stab_types
 553 
void
530 
    PROTO_Z ()
 554 
init_stab_types(void)
531 
{
 555 
{
532 
    static char *stab_types [] = {
 556 
	static char *stab_types[] = {
533 
	"\"int:t1=r1;-2147483648;2147483647;\"",
 557 
		"\"int:t1=r1;-2147483648;2147483647;\"",
534 
	"\"char:t2=r2;0;127;\"",
 558 
		"\"char:t2=r2;0;127;\"",
535 
	"\"long int:t3=r1;-2147483648;2147483647;\"",
 559 
		"\"long int:t3=r1;-2147483648;2147483647;\"",
536 
	"\"unsigned int:t4=r1;0;-1;\"",
 560 
		"\"unsigned int:t4=r1;0;-1;\"",
537 
	"\"long unsigned int:t5=r1;0;-1;\"",
 561 
		"\"long unsigned int:t5=r1;0;-1;\"",
538 
	"\"short int:t6=r1;-32768;32767;\"",
 562 
		"\"short int:t6=r1;-32768;32767;\"",
539 
	"\"long long int:t7=r1;0;-1;\"",
 563 
		"\"long long int:t7=r1;0;-1;\"",
540 
	"\"short unsigned int:t8=r1;0;65535;\"",
 564 
		"\"short unsigned int:t8=r1;0;65535;\"",
541 
	"\"long long unsigned int:t9=r1;0;-1;\"",
 565 
		"\"long long unsigned int:t9=r1;0;-1;\"",
542 
	"\"signed char:t10=r1;-128;127;\"",
 566 
		"\"signed char:t10=r1;-128;127;\"",
543 
	"\"unsigned char:t11=r1;0;255;\"",
 567 
		"\"unsigned char:t11=r1;0;255;\"",
544 
	"\"float:t12=r1;4;0;\"",
 568 
		"\"float:t12=r1;4;0;\"",
545 
	"\"double:t13=r1;8;0;\"",
 569 
		"\"double:t13=r1;8;0;\"",
546 
	"\"long double:t14=r1;8;0;\"",
 570 
		"\"long double:t14=r1;8;0;\"",
547 
	"\"void:t15=15\""
 571 
		"\"void:t15=15\""
548 
    } ;
 572 
	};
549 
    int i ;
 573 
	int i;
550 
    for ( i = 0 ; i < 15 ; i++ ) {
 574 
	for (i = 0; i < 15; i++) {
551 
	make_stabs ( stab_types [i], 128, L0, null ) ;
 575 
		make_stabs(stab_types[i], 128, L0, null);
552 
    }
 576 
	}
553 
    return ;
 577 
	return;
554 
}
 578 
}