]> andersk Git - moira.git/blame - gdb/gdb_stype.c
Case-insensitive stuff.
[moira.git] / gdb / gdb_stype.c
CommitLineData
5580185e 1/*
2 * $Source$
3 * $Header$
4 */
5
6#ifndef lint
7static char *rcsid_gdb_stype_c = "$Header$";
8#endif lint
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30/************************************************************************/
31/*
32/* gdb_stype.c
33/*
34/* GDB - System Data Type Definitions
35/*
36/* Author: Noah Mendelsohn
37/* Copyright: 1986 MIT Project Athena
0a5ff702 38/* For copying and distribution information, please see
39/* the file <mit-copyright.h>.
5580185e 40/*
41/* This file initializes the definitions for all system defined
42/* data types, and it includes the type specific semantic routines
43/* for each of the system defined types.
44/*
45/* The initialization routine which adds these type definitions
46/* to the type definition table is at the end of this source file.
47/*
48/************************************************************************/
49/*
50/* This file is organized into one section for each system
51/* defined type followed at the end by a final section which
52/* initializes the type tables. Each of the type specific
53/* sections does #defines for each type specific parameter. The
54/* gdb_i_stype initialization routine at the end of this source
55/* file uses these defines to initialize the appropriate entry in
56/* the type definition tables.
57/*
58/* NOTE: some of the type definitions in this file may be machine
59/* dependent.
60/*
61/************************************************************************/
62
0a5ff702 63#include <mit-copyright.h>
5580185e 64#include <stdio.h>
65#include <strings.h>
66#include "gdb.h"
67#ifdef vax /* XXX */
68 extern u_long ntohl(), htonl();
69#endif vax
70#include <netinet/in.h> /* for htonl routine */
71\f
72/************************************************************************/
73/*
74/* INTEGER_T
75/*
76/************************************************************************/
77
78#define IN_LEN (sizeof(int))
79#define IN_ALI IN_LEN
80#define IN_NULL g_in_null
81#define IN_CDLEN g_in_cdlen
82#define IN_ENC g_in_enc
83#define IN_DEC g_in_dec
84#define IN_FORM g_in_form
85#define IN_NAME "INTEGER_T"
86
87#define IN_EXTERNSIZE 4 /* length of an encoded */
88 /* integer */
89 /*----------------------------------------------------------*/
90 /*
91 /* g_in_null
92 /*
93 /* Fill in a null value for an integer.
94 /*
95 /*----------------------------------------------------------*/
96
97int
98g_in_null(dp)
99char *dp; /* pointer to the data */
100{
101 *((int *)dp) = 0; /* fill in a null value */
102}
103
104 /*----------------------------------------------------------*/
105 /*
106 /* g_in_cdlen
107 /*
108 /* Return coded length for an integer. We're currently
109 /* using the Berkeley 'htonl' routine which converts
110 /* an integer (actually a long, ahem!) to a canonical
111 /* 4 byte form.>
112 /*
113 /*----------------------------------------------------------*/
114
115
24582af9 116/*ARGSUSED*/
5580185e 117int
118g_in_cdlen(dp,hcon)
119char *dp; /* pointer to the data */
120HALF_CONNECTION hcon;
121{
122 return IN_EXTERNSIZE;
123}
124
125 /*----------------------------------------------------------*/
126 /*
127 /* g_in_enc
128 /*
129 /* Encode an integer for transmission
130 /*
131 /*----------------------------------------------------------*/
132
24582af9 133/*ARGSUSED*/
5580185e 134int
135g_in_enc(dp, hcon, outp)
136char *dp; /* pointer to data */
137HALF_CONNECTION hcon; /* connection descriptor */
138char *outp; /* place to put the output */
139{
140 register char *cp; /* next char in output */
141 register char *op = outp;
142 register char *endp = outp+IN_EXTERNSIZE;
143
144 unsigned long converted; /* the integer goes here */
145 /* in network byte order*/
146
147 /*
148 * Put it in network format, then copy one byte at a time to
149 * account for the fact that the RT has trouble with unaligned longs
150 */
151
152 converted = htonl(*(u_long *)dp);
153
154 cp = (char *)&converted;
155 *op++ = *cp++;
156 *op++ = *cp++;
157 *op++ = *cp++;
158 *op++ = *cp++;
159
160 return (int)(endp); /* return pointer to next */
161 /* unused output byte*/
162}
163
164 /*----------------------------------------------------------*/
165 /*
166 /* g_in_dec
167 /*
168 /* Decode an integer from external form to local
169 /* representation.
170 /*
171 /*
172 /*----------------------------------------------------------*/
173
24582af9 174/*ARGSUSED*/
5580185e 175int
176g_in_dec(outp, hcon, inp)
177char *inp; /* pointer to data */
178HALF_CONNECTION hcon; /* connection descriptor */
179char *outp; /* place to put the output */
180{
181 register char *ip = inp; /* next byte of input */
182 int buffer;
183 register char *bp; /* next byte in buffer */
184
185 /*
186 * Copy a byte at a time to buffer to account for RT difficulties
187 * with unaligned ints.
188 */
189 bp = (char *)&buffer;
190 *bp++ = *ip++;
191 *bp++ = *ip++;
192 *bp++ = *ip++;
193 *bp++ = *ip++;
194
195 /*
196 * Convert it and return pointer to next byte of input.
197 */
198
199 *(int *)outp = ntohl((u_long)buffer);
200 return (int)(ip);
201}
202
203 /*----------------------------------------------------------*/
204 /*
205 /* g_in_form
206 /*
207 /* Format an integer on output logging file for
208 /* debugging.
209 /*
210 /*----------------------------------------------------------*/
211
212int
213g_in_form(name, dp)
214char *name; /* string name of the field */
215char *dp; /* pointer to the data */
216{
217 fprintf(gdb_log, "INTEGER_T\t%s=%d\n",name,(*(int *)dp));
218}
219\f
220/************************************************************************/
221/*
222/* STRING_T
223/*
224/************************************************************************/
225
226#define ST_LEN (sizeof(STRING))
227#define ST_ALI (sizeof(int))
228#define ST_NULL g_st_null
229#define ST_CDLEN g_st_cdlen
230#define ST_ENC g_st_enc
231#define ST_DEC g_st_dec
232#define ST_FORM g_st_form
233#define ST_NAME "STRING_T"
234
235 /*----------------------------------------------------------*/
236 /*
237 /* g_st_null
238 /*
239 /* Fill in a null value for a string.
240 /*
241 /*----------------------------------------------------------*/
242int
243g_st_null(dp)
244char *dp; /* pointer to the data */
245{
246 register STRING *stp = (STRING *)dp; /* re-type as string */
247 STRING_DATA(*stp) = NULL; /* no data */
248 MAX_STRING_SIZE(*stp) = 0; /* for cleanliness */
249}
250
251 /*----------------------------------------------------------*/
252 /*
253 /* g_st_cdlen
254 /*
255 /* Return coded length for a string. We have to send the
256 /* actual length of the data along with the data itself.
257 /* For this reason, we leave space for a coded integer
258 /* in addition to the data bytes. We actually call the
259 /* integer coding routines to code the length.
260 /*
261 /* Note that a separate type understanding null termination
262 /* might be an interesting optimization someday.
263 /*
264 /*----------------------------------------------------------*/
265
266int
267g_st_cdlen(dp,hcon)
268char *dp; /* pointer to the data */
269HALF_CONNECTION hcon;
270{
271 register STRING *stp = (STRING *)dp; /* re-type as string */
272
273 return (MAX_STRING_SIZE(*stp) +
274 g_in_cdlen((char *)&MAX_STRING_SIZE(*stp),hcon));
275}
276
277 /*----------------------------------------------------------*/
278 /*
279 /* g_st_enc
280 /*
281 /* Encode a string for transmission
282 /*
283 /*----------------------------------------------------------*/
284
285int
286g_st_enc(dp, hcon, outp)
287char *dp; /* pointer to data */
288HALF_CONNECTION hcon; /* connection descriptor */
289char *outp; /* place to put the output */
290{
291 register STRING *stp = (STRING *)dp; /* re-type as string */
292 int len;
293 register char *nextp; /* place to put next output */
294 /* byte */
295 /*
296 * Use the integer coding routine to get the length encoded first
297 */
298
299 len = MAX_STRING_SIZE(*stp); /* length of both source */
300 /* and coded form*/
301 nextp = (char *)g_in_enc((char *)&len, hcon, outp);
302
303 /*
304 * Now, copy the data itself after the encoded integer length
305 */
306 if (len > 0)
307 bcopy(STRING_DATA(*stp), nextp, len);
308 /* copy the data without */
309 /* changing representation*/
310 return (int)(nextp+len);
311}
312
313 /*----------------------------------------------------------*/
314 /*
315 /* g_st_dec
316 /*
317 /* Decode a string from external form. We always
318 /* allocate new space for the string, intentionally
319 /* ignoring any which may have been in use before. If we
320 /* freed it, we would not be robust against calls on
321 /* uninitialized fields. This may have nasty side
322 /* effects if the intention was to leave 'gas' at the end
323 /* of the string, but we want to accurately copy the
324 /* data. Note that string_free is robust against null
325 /* pointers.
326 /*
327 /*----------------------------------------------------------*/
328
329int
330g_st_dec(outp, hcon, inp)
331char *inp; /* pointer to input data */
332HALF_CONNECTION hcon; /* connection descriptor */
333char *outp; /* place to put the output */
334{
335 register STRING *stp = (STRING *)outp; /* re-type as string */
336 int len;
337 register char *nextp; /* next byte to scan */
338 /*
339 * Use the integer coding routine to get the length encoded first
340 */
341
342 nextp = (char *)g_in_dec((char *)&len, hcon, inp);
343
344
345 /*
346 * Allocate memory for the string. If length is 0, then null it
347 * out. Note that we had considered freeing any existing strings
348 * which might be there, but this turns out to cause lots of
349 * trouble for the many callers who don't want to initialize before
350 * a decode.
351 */
352 if (len == 0) {
353 STRING_DATA(*stp) = NULL;
354 MAX_STRING_SIZE(*stp) = 0;
355 return (int)(nextp);
356 }
357 (void) string_alloc(stp, len); /* this sets string length */
358 /* in addition to doing the */
359 /* allocation */
360
361 /*
362 * Now, copy the data itself
363 */
364 bcopy(nextp, STRING_DATA(*stp), len); /* copy the data without */
365 /* changing representation*/
366 return (int)(nextp+len);
367}
368
369 /*----------------------------------------------------------*/
370 /*
371 /* g_st_form
372 /*
373 /* Format a string on output logging file for
374 /* debugging.
375 /*
376 /*----------------------------------------------------------*/
377
378int
379g_st_form(name, dp)
380char *name; /* string name of the field */
381char *dp; /* pointer to the data */
382{
383 register STRING *stp = (STRING *)dp; /* re-type as string */
384 int len;
385 register char *cp; /* next char to print */
386 register char *past_end; /* 1st one not to print */
387
388 len = MAX_STRING_SIZE(*stp);
389 fprintf(gdb_log, "STRING_T\t%s[%d]=\"", name,len);
390
391 if (len == 0 ) {
392 fprintf(gdb_log, "\"\n");
393 return;
394 }
395
396
397 cp = STRING_DATA(*stp);
398 past_end = cp + len;
399
400 while (cp < past_end)
401 (void) putc(*cp++, gdb_log);
402
403 fprintf(gdb_log,"\"\n");
404}
405\f
406/************************************************************************/
407/*
408/* REAL_T
409/*
410/************************************************************************/
411
412#define RL_LEN (sizeof(double))
413#define RL_ALI RL_LEN
414#define RL_NULL g_rl_null
415#define RL_CDLEN g_rl_cdlen
416#define RL_ENC g_rl_enc
417#define RL_DEC g_rl_dec
418#define RL_FORM g_rl_form
419#define RL_NAME "REAL_T"
420
421#define RL_EXTERNSIZE 32 /* length of ascii coding */
422 /* must change lengths in */
423 /* encode and decode */
424 /* routines to match*/
425 /*----------------------------------------------------------*/
426 /*
427 /* g_rl_null
428 /*
429 /* Fill in a null value for an real.
430 /*
431 /*----------------------------------------------------------*/
432int
433g_rl_null(dp)
434char *dp; /* pointer to the data */
435{
436 *((double *)dp) = 0.0; /* fill in a null value */
437}
438
439 /*----------------------------------------------------------*/
440 /*
441 /* g_rl_cdlen
442 /*
443 /* Return coded length for an real. For now, we just
444 /* code as a 12 digit ASCII converted string. Obviously,
445 /* we can do much better in the future.
446 /*
447 /*----------------------------------------------------------*/
448
449
24582af9 450/*ARGSUSED*/
5580185e 451int
452g_rl_cdlen(dp,hcon)
453char *dp; /* pointer to the data */
454HALF_CONNECTION hcon;
455{
456 return RL_EXTERNSIZE;
457}
458
459 /*----------------------------------------------------------*/
460 /*
461 /* g_rl_enc
462 /*
463 /* Encode an real for transmission
464 /*
465 /*----------------------------------------------------------*/
466
24582af9 467/*ARGSUSED*/
5580185e 468int
469g_rl_enc(dp, hcon, outp)
470char *dp; /* pointer to data */
471HALF_CONNECTION hcon; /* connection descriptor */
472char *outp; /* place to put the output */
473{
474 register char *cp; /* next char in output */
475 register char *endp = outp+RL_EXTERNSIZE;
476
477 /*
478 * Convert the data into printable ASCII in the output stream
479 * Note that the width in the format below must be less than
480 * RL_EXTERNSIZE, because sprintf needs space for its terminating
481 * null.
482 */
483
484 (void) sprintf(outp,"%30le",*((double *)dp));
485
486 /*
487 * Sprintf produces output of unpredictable length, and with
488 * a null termination. Pad it out to the desired length.
489 */
490
491 cp = outp + strlen(outp); /* find out where convertd */
492 /* string stops*/
493 while (cp < endp)
494 *cp++ = ' '; /* pad to desired length */
495
496 return (int)(outp+RL_EXTERNSIZE); /* return pointer to next */
497 /* unused output byte*/
498}
499
500 /*----------------------------------------------------------*/
501 /*
502 /* g_rl_dec
503 /*
504 /* Decode an real from external form
505 /*
506 /*----------------------------------------------------------*/
507
24582af9 508/*ARGSUSED*/
5580185e 509int
510g_rl_dec(outp, hcon, inp)
511char *inp; /* pointer to data */
512HALF_CONNECTION hcon; /* connection descriptor */
513char *outp; /* place to put the output */
514{
515 (void) sscanf(inp,"%30le", (double *)outp);
516 return (int)(inp+RL_EXTERNSIZE);
517}
518
519 /*----------------------------------------------------------*/
520 /*
521 /* g_rl_form
522 /*
523 /* Format an real on output logging file for
524 /* debugging.
525 /*
526 /*----------------------------------------------------------*/
527
528int
529g_rl_form(name, dp)
530char *name; /* string name of the field */
531char *dp; /* pointer to the data */
532{
533 fprintf(gdb_log, "REAL_T\t\t%s=%le\n",name,*((double *)dp) );
534}
535\f
536/************************************************************************/
537/*
538/* DATE_T
539/*
540/************************************************************************/
541
542#define DT_LEN 25 /* see ingres definition */
543#define DT_ALI 1 /* char data, need not align */
544#define DT_NULL g_dt_null
545#define DT_CDLEN g_dt_cdlen
546#define DT_ENC g_dt_enc
547#define DT_DEC g_dt_dec
548#define DT_FORM g_dt_form
549#define DT_NAME "DATE_T"
550
551#define DT_EXTERNSIZE DT_LEN /* length of ascii coding */
552 /* must change lengths in */
553 /* encode and decode */
554 /* routines to match*/
555 /*----------------------------------------------------------*/
556 /*
557 /* g_dt_null
558 /*
559 /* Fill in a null value for a date.
560 /*
561 /*----------------------------------------------------------*/
562int
563g_dt_null(dp)
564char *dp; /* pointer to the data */
565{
566 register char *cp = dp; /* next character to fill in */
567 register char *endp = dp + DT_LEN;
568
569 /*
570 * Fill the field with character blanks
571 */
572 while (cp < endp)
573 *cp++ = ' ';
574}
575
576 /*----------------------------------------------------------*/
577 /*
578 /* g_dt_cdlen
579 /*
580 /* Return coded length for an date. For now, we just
581 /* code as a 25 digit ASCII converted string.
582 /*
583 /*----------------------------------------------------------*/
584
585
24582af9 586/*ARGSUSED*/
5580185e 587int
588g_dt_cdlen(dp,hcon)
589char *dp; /* pointer to the data */
590HALF_CONNECTION hcon;
591{
592 return DT_EXTERNSIZE;
593}
594
595 /*----------------------------------------------------------*/
596 /*
597 /* g_dt_enc
598 /*
599 /* Encode a date for transmission
600 /*
601 /*----------------------------------------------------------*/
602
24582af9 603/*ARGSUSED*/
5580185e 604int
605g_dt_enc(dp, hcon, outp)
606char *dp; /* pointer to data */
607HALF_CONNECTION hcon; /* connection descriptor */
608char *outp; /* place to put the output */
609{
610 register char *ip = dp; /* next char in input */
611 register char *op = outp; /* next char in output */
612 register char *endp = op+DT_EXTERNSIZE;
613
614 /*
615 * Copy the input untransformed to the output
616 */
617
618 while (op < endp)
619 *op++ = *ip++; /* pad to desired length */
620
621 return (int)(endp); /* return pointer to next */
622 /* unused output byte*/
623}
624
625 /*----------------------------------------------------------*/
626 /*
627 /* g_dt_dec
628 /*
629 /* Decode an date from external form
630 /*
631 /*----------------------------------------------------------*/
632
24582af9 633/*ARGSUSED*/
5580185e 634int
635g_dt_dec(outp, hcon, inp)
636char *inp; /* pointer to data */
637HALF_CONNECTION hcon; /* connection descriptor */
638char *outp; /* place to put the output */
639{
640 register char *ip = inp; /* next char in input */
641 register char *op = outp; /* next char in output */
642 register char *endp = op+DT_EXTERNSIZE;
643
644 /*
645 * Copy the input untransformed to the output
646 */
647
648 while (op < endp)
649 *op++ = *ip++; /* pad to desired length */
650
651 return (int)(endp); /* return pointer to next */
652 /* unused output byte*/
653}
654
655 /*----------------------------------------------------------*/
656 /*
657 /* g_dt_form
658 /*
659 /* Format a date on output logging file for
660 /* debugging.
661 /*
662 /*----------------------------------------------------------*/
663
664int
665g_dt_form(name, dp)
666char *name; /* string name of the field */
667char *dp; /* pointer to the data */
668{
669 char buf[DT_EXTERNSIZE+1];
670
671 bcopy(dp, buf, DT_EXTERNSIZE); /* copy date to buffer */
672 buf[DT_EXTERNSIZE] = '\0'; /* null terminate it */
673 fprintf(gdb_log, "DATE_T\t\t%s=%s\n",name,buf);
674}
675\f
676/************************************************************************/
677/*
678/* TUPLE_DESCRIPTOR_T
679/*
680/* The external representation of a tuple descriptor will be to
681/* send the count of the number of fields, and then a one byte
682/* signed integer describing each type followed by all the
683/* corresponding null terminated strings. The tuple descriptor
684/* will really get re-created wth proper offsets and lengths upon
685/* receipt by the create_tuple_descriptor operation.
686/*
687/************************************************************************/
688
689#define TPD_LEN (sizeof(TUPLE_DESCRIPTOR))
690#define TPD_ALI (sizeof(TUPLE_DESCRIPTOR))
691#define TPD_NULL g_tpd_null
692#define TPD_CDLEN g_tpd_cdlen
693#define TPD_ENC g_tpd_enc
694#define TPD_DEC g_tpd_dec
695#define TPD_FORM g_tpd_form
696#define TPD_NAME "TUPLE_DESCRIPTOR_T"
697
698 /*----------------------------------------------------------*/
699 /*
700 /* g_tpd_null
701 /*
702 /* Fill in a null value for a tuple_descriptor.
703 /*
704 /*----------------------------------------------------------*/
705int
706g_tpd_null(dp)
707char *dp; /* pointer to the data */
708{
709 register TUPLE_DESCRIPTOR *tdp = (TUPLE_DESCRIPTOR *)dp;
710 /* re-type as */
711 /* tuple_descriptor */
712 (*tdp) = NULL; /* no data */
713}
714
715 /*----------------------------------------------------------*/
716 /*
717 /* g_tpd_cdlen
718 /*
719 /* Return coded length for a tuple_descriptor.
720 /*
721 /*----------------------------------------------------------*/
722
723int
724g_tpd_cdlen(dp,hcon)
725char *dp; /* pointer to the data */
726HALF_CONNECTION hcon;
727{
728 register TUPLE_DESCRIPTOR tdp = *((TUPLE_DESCRIPTOR *)dp);
729 /* re-type as */
730 /* tuple_descriptor */
731 register int coded_len; /* the value we're trying */
732 /* to compute */
733
734 /*
735 * Validate the descriptor
736 */
737 if (tdp == NULL)
738 GDB_GIVEUP("g_tpd_cdlen (coded length) was given a null tuple descriptor\nthis may be due to an attempt to transmit invalid data")
739 GDB_CHECK_TPD(tdp,"g_tpd_cdlen: compute coded length of tuple descriptor")
740
741 coded_len = g_in_cdlen((char *)&(tdp->field_count),hcon);
742 /* we're going to send */
743 /* the field count as a */
744 /* true integer*/
745
746 coded_len += tdp->str_len + tdp->field_count;
747 /* space for all the */
748 /* strings, with nulls, */
749 /* and for the one byte */
750 /* types*/
751
752 return coded_len;
753
754}
755
756 /*----------------------------------------------------------*/
757 /*
758 /* g_tpd_enc
759 /*
760 /* Encode a tuple_descriptor for transmission
761 /*
762 /*----------------------------------------------------------*/
763
764int
765g_tpd_enc(dp, hcon, outp)
766char *dp; /* pointer to data */
767HALF_CONNECTION hcon; /* connection descriptor */
768char *outp; /* place to put the output */
769{
770 register TUPLE_DESCRIPTOR tdp = *((TUPLE_DESCRIPTOR *)dp);
771 /* re-type as */
772 /* tuple_descriptor */
773 register char *nextp; /* place to put next output */
774 /* byte */
775 register int i; /* a loop counter */
776
777 /*
778 * Validate the descriptor
779 */
780 if (tdp == NULL)
781 GDB_GIVEUP("g_tpd_enc (encode) was given a null tuple descriptor\nthis may be due to an attempt to transmit invalid data")
782 GDB_CHECK_TPD(tdp,"g_tpd_enc: encode tuple descriptor")
783
784 /*
785 * Use the integer coding routine to send the number of fields first
786 */
787 /* and coded form*/
788 nextp = (char *)g_in_enc((char *)&(tdp->field_count), hcon, outp);
789
790 /*
791 * Next, put in the one byte codes for each of the field types
792 */
793
794 for (i=0; i<tdp->field_count; i++) {
795 *nextp++ = tdp->var[i].type & 0xff; /* put out the one byte */
796 /* type codes */
797 }
798
799 /*
800 * Finally, copy all the null terminated strings.
801 */
802 bcopy(((char *)(tdp))+gdb_descriptor_length(tdp->field_count),
803 nextp, tdp->str_len); /* copy the string data all */
804 /* at once */
805 return (int)(nextp+tdp->str_len);
806}
807
808 /*----------------------------------------------------------*/
809 /*
810 /* g_tpd_dec
811 /*
812 /* Decode a tuple_descriptor from external form. For
813 /* safety in memory management, we always re-allocate the
814 /* space for the tuple_descriptor. If the pointer passed
815 /* to us is not null, then we assume that it points to a
816 /* legal tuple descriptor, which we first free. Because
817 /* data representation may change, we must re-do the
818 /* create-tuple-descriptor, so it can determine the local
819 /* machine dependent representation and alignment rules
820 /* for the data.
821 /*
822 /*----------------------------------------------------------*/
823
824#define GDB_MAX_DECODED_FIELDS 100
825
826int
827g_tpd_dec(outp, hcon, inp)
828char *inp; /* pointer to input data */
829HALF_CONNECTION hcon; /* connection descriptor */
830char *outp; /* place to put the output */
831{
832 register TUPLE_DESCRIPTOR *tdp = (TUPLE_DESCRIPTOR *)outp;
833 /* re-type as */
834 /* tuple_descriptor */
835 int field_count; /* number of fields in the */
836 /* newly received descriptor*/
837 register int i; /* a loop counter */
838
839 register int tmp; /* working variable to hold */
840 /* type while they're being */
841 /* sign extended */
842 char *nextt; /* next byte to scan for */
843 /* a type code byte*/
844 char *nextn; /* next byte to scan for */
845 /* a string name */
846 char *field_names[GDB_MAX_DECODED_FIELDS];
847 /* put pointers to the */
848 /* field names here */
849 FIELD_TYPE field_types[GDB_MAX_DECODED_FIELDS];
850 /* put the field types in */
851 /* the array here*/
852 /*
853 * Use the integer coding routine to get the number of fields
854 */
855
856 nextt = (char *)g_in_dec((char *)&field_count, hcon, inp);
857 if (field_count > GDB_MAX_DECODED_FIELDS)
858 GDB_GIVEUP("g_tpd_dec: Trying to decode tuple descriptor with too many fields.\n")
859
860
861 /*
862 * For each field, pick up its type code, being sure to sign extend,
863 * and a pointer to its string name.
864 */
865 nextn = nextt + field_count; /* there is one byte of */
866 /* type info for each field, */
867 /* after that comes the */
868 /* first string. nextn */
869 /* now points to the first */
870 /* string */
871 for (i=0; i<field_count; i++) {
872 tmp = *nextt++; /* type code, may need */
873 /* sign extension */
874 if (tmp & 0x80)
875 tmp |= ((~0) ^ 0xff); /* sign extend if needed */
876 /* this is the most machine */
877 /* independent sign extension */
878 /* I could come up with. */
879 /* Presumes char is one byte, */
880 /* but makes no assumption */
881 /* about sizeof(int) */
882 field_types[i] = tmp;
883 field_names[i] = nextn; /* pointer to name of the */
884 /* field */
885 nextn += strlen(nextn) +1; /* set up for possible name */
886 /* to follow */
887 }
888
889 /*
890 * In case there was already a tuple descriptor here, free it.
891 */
892
893 delete_tuple_descriptor(*tdp);
894
895 /*
896 * Create a new descriptor based on the information we have received.
897 */
898 *tdp = create_tuple_descriptor(field_count, field_names, field_types);
899
900 return (int)nextn;
901}
902
903 /*----------------------------------------------------------*/
904 /*
905 /* g_tpd_form
906 /*
907 /* Format a tuple_descriptor on output logging file for
908 /* debugging.
909 /*
910 /*----------------------------------------------------------*/
911
912int
913g_tpd_form(name, dp)
914char *name; /* tuple_descriptor name of the field */
915char *dp; /* pointer to the data */
916{
917 register TUPLE_DESCRIPTOR tdp = *((TUPLE_DESCRIPTOR *)dp);
918 /* re-type as */
919 /* tuple_descriptor */
920 register int i; /* loop variable through */
921 /* field definitions */
922
923
924 /*
925 * Handle the special case where the descriptor is null
926 */
927 if (tdp == NULL) {
928 fprintf(gdb_log, "TUPLE_DESCRIPTOR %s (loc=NULL)\n", name);
929 return;
930 }
931
932 /*
933 * Validate the descriptor
934 */
935 GDB_CHECK_TPD(tdp,"g_tpd_form: format tuple descriptor")
936
937 /*
938 * Descriptor is not null
939 */
940 fprintf(gdb_log, "TUPLE_DESCRIPTOR %s (loc=0x%x)\n", name, tdp);
941
942 for (i=0; i<tdp->field_count; i++) {
943 fprintf(gdb_log,"\tField Type Code = %3d %20s\tField Name=%s\n" ,
944 tdp->var[i].type,
945 STR_PROPERTY(tdp->var[i].type,NAME_PROPERTY),
946 tdp->var[i].name);
947 }
948 fprintf(gdb_log,"\n");
949}
950\f
951/************************************************************************/
952/*
953/* TUPLE_T
954/*
955/* There is a distinction between the type tuple_t and the
956/* type tuple_data_t. Tuple_t is a complete self-contained
957/* tuple, with its descriptor. It actually refers to the
958/* tuple variable itself, which is a pointer. Tuple_data
959/* is only the data portion of the tuple, not the descriptor.
960/* It is used when the receiving tuple is already allocated,
961/* with a correct descriptor, for sending just the data.
962/*
963/* Note that some of the routines for tuple_t could have been
964/* implemented in terms of tuple_data_t routines. For the
965/* moment, they have not been, but that may later be changed.
966/* Doesn't seem to make much difference as long as they are
967/* short and simple, and this way does save a bit of overhead.
968/*
969/************************************************************************/
970
971#define TP_LEN (sizeof(TUPLE))
972#define TP_ALI TP_LEN
973#define TP_NULL g_tp_null
974#define TP_CDLEN g_tp_cdlen
975#define TP_ENC g_tp_enc
976#define TP_DEC g_tp_dec
977#define TP_FORM g_tp_form
978#define TP_NAME "TUPLE_T"
979
980 /*----------------------------------------------------------*/
981 /*
982 /* g_tp_null
983 /*
984 /* Fill in a null value for a tuple.
985 /*
986 /*----------------------------------------------------------*/
987int
988g_tp_null(dp)
989char *dp; /* pointer to the data */
990{
991 *((TUPLE *)dp) = NULL;
992}
993
994 /*----------------------------------------------------------*/
995 /*
996 /* g_tp_cdlen
997 /*
998 /* Return coded length for a tuple. We have to send the
999 /* descriptor along with the data itself. We do this
1000 /* with calls to the appropriate encodeing routines.
1001 /*
1002 /*----------------------------------------------------------*/
1003
1004int
1005g_tp_cdlen(dp,hcon)
1006char *dp; /* pointer to the data */
1007HALF_CONNECTION hcon;
1008{
1009 register TUPLE tup = *((TUPLE *)dp); /* deref as tuple */
1010 register int len; /* accumulated length */
1011 register int i; /* index to fields */
1012 TUPLE_DESCRIPTOR tpd; /* descriptor for this tuple */
1013
1014 /*
1015 * Validate the tuple
1016 */
1017 if (tup == NULL)
1018 GDB_GIVEUP("g_tp_cdlen (coded length) was given a null tuple\nthis may be due to an attempt to transmit invalid data")
1019 GDB_CHECK_TUP(tup,"g_tp_cdlen: compute coded length of tuple")
1020
1021 /*
1022 * First, get length of the descriptor when coded.
1023 */
1024
1025 tpd = DESCRIPTOR_FROM_TUPLE(tup);
1026 len = g_tpd_cdlen((char *)&tpd,hcon);
1027
1028 /*
1029 * Now, for each field, add in its coded length
1030 */
1031
1032 for (i=0; i<tpd->field_count; i++) {
1033 len += (int)FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),
1034 CODED_LENGTH_PROPERTY)
1035 (FIELD_FROM_TUPLE(tup, i),hcon);
1036 }
1037
1038 return len;
1039}
1040
1041 /*----------------------------------------------------------*/
1042 /*
1043 /* g_tp_enc
1044 /*
1045 /* Encode a tuple for transmission
1046 /*
1047 /*----------------------------------------------------------*/
1048
1049int
1050g_tp_enc(dp, hcon, outp)
1051char *dp; /* pointer to data */
1052HALF_CONNECTION hcon; /* connection descriptor */
1053char *outp; /* place to put the output */
1054{
1055 register TUPLE tup = *((TUPLE *)dp); /* deref as tuple */
1056 register int i; /* index to fields */
1057 TUPLE_DESCRIPTOR tpd; /* descriptor for this tuple */
1058 char *op; /* next byte of output */
1059
1060 /*
1061 * Validate the tuple
1062 */
1063 if (tup == NULL)
1064 GDB_GIVEUP("g_tp_enc (encode) was given a null tuple\nthis may be due to an attempt to transmit invalid data")
1065 GDB_CHECK_TUP(tup,"g_tp_enc: encode tuple")
1066
1067 /*
1068 * First, get the tuple descriptor and encode it
1069 */
1070
1071 tpd = DESCRIPTOR_FROM_TUPLE(tup);
1072 op = (char *)g_tpd_enc((char *)&tpd, hcon, outp);
1073
1074 /*
1075 * Now, for each field, code it
1076 */
1077
1078 for (i=0; i<tpd->field_count; i++) {
1079 op = (char *)FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),
1080 ENCODE_PROPERTY)
1081 (FIELD_FROM_TUPLE(tup, i),hcon, op);
1082 }
1083
1084 return (int)op;
1085}
1086
1087 /*----------------------------------------------------------*/
1088 /*
1089 /* g_tp_dec
1090 /*
1091 /* Decode a tuple from external form. For safety
1092 /* in memory management, we always re-allocate the
1093 /* space for the tuple, so the lengths come out right.
1094 /* This may have nasty side effects if the intention
1095 /* was to leave 'gas' at the end of the tuple, but
1096 /* we want to accurately copy the data. Note that
1097 /* tuple_free is robust against null pointers.
1098 /*
1099 /*----------------------------------------------------------*/
1100
1101int
1102g_tp_dec(outp, hcon, inp)
1103char *inp; /* pointer to input data */
1104HALF_CONNECTION hcon; /* connection descriptor */
1105char *outp; /* place to put the output */
1106{
1107 register TUPLE tup; /* the new tuple */
1108 register int i; /* index to fields */
1109 TUPLE_DESCRIPTOR tpd; /* descriptor for this tuple */
1110 char *ip; /* next byte of input */
1111
1112 /*
1113 * First, get the tuple descriptor and decode it
1114 */
1115
1116 tpd = NULL; /* so decode will know */
1117 /* there's no existing one */
1118 /* to free */
1119 ip = (char *)g_tpd_dec((char *)&tpd, hcon, inp);
1120
1121 /*
1122 * Now make an empty tuple based on the descriptor
1123 */
1124
1125 tup = create_tuple(tpd);
1126
1127 /*
1128 * The tuple descriptor has a reference count of 2 here, one
1129 * from the tpd_dec routine, and one from the create_tuple.
1130 * Since we don't expect to explicitly undo the two separately,
1131 * we decrement the count here.
1132 */
1133
1134 UNREFERENCE_TUPLE_DESCRIPTOR(tpd); /* decr. the reference count */
1135
1136 /*
1137 * Now, for each field, decode it.
1138 */
1139
1140 for (i=0; i<tpd->field_count; i++) {
1141 ip = (char *)FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),
1142 DECODE_PROPERTY)
1143 (FIELD_FROM_TUPLE(tup, i),hcon, ip);
1144 }
1145
1146 *((TUPLE *)outp) = tup; /* put the new tuple */
1147 /* pointer where the */
1148 /* caller wants it */
1149 return (int)ip;
1150}
1151
1152 /*----------------------------------------------------------*/
1153 /*
1154 /* g_tp_form
1155 /*
1156 /* Format a tuple on output logging file for
1157 /* debugging.
1158 /*
1159 /*----------------------------------------------------------*/
1160
1161int
1162g_tp_form(name, dp)
1163char *name; /* tuple name of the field */
1164char *dp; /* pointer to the data */
1165{
1166 register TUPLE tup = *((TUPLE *)dp); /* deref as tuple */
1167 register int i; /* index to fields */
1168 TUPLE_DESCRIPTOR tpd; /* descriptor for this tuple */
1169
1170
1171 /*
1172 * Handle special case where tuple is null
1173 */
1174
1175 if (tup==NULL) {
1176 fprintf(gdb_log,"\nTUPLE Name=%s is NULL\n---------------------------\n",name);
1177 return;
1178 }
1179
1180 GDB_CHECK_TUP(tup,"g_tp_form: format tuple")
1181 /*
1182 * Get the descriptor--for now, we won't print it
1183 */
1184 tpd = DESCRIPTOR_FROM_TUPLE(tup);
1185
1186 /*
1187 * Print a header
1188 */
1189
1190 fprintf(gdb_log,"\nTUPLE at address: 0x%x Name=%s\n---------------------------\n",tup,name);
1191
1192 /*
1193 * Now, for each field, print it
1194 */
1195
1196 for (i=0; i<tpd->field_count; i++) {
1197 FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),
1198 FORMAT_PROPERTY)
1199 (tpd->var[i].name,FIELD_FROM_TUPLE(tup, i));
1200 }
1201
1202 fprintf(gdb_log,"END_OF_TUPLE\n");
1203}
1204\f
1205/************************************************************************/
1206/*
1207/* TUPLE_DATA_T
1208/*
1209/* The distinction between tuple_data_t and tuple_t is a
1210/* subtle one. Tuple_t is used when a single tuple is to
1211/* be decoded, outside of any larger context. It (re)allocates
1212/* memory for both the tuple itself and its descriptor.
1213/*
1214/* Tuple_data is used in the case where the tuple and its
1215/* descriptor are already allocated, but only the data is
1216/* to be received. This is useful in cases like receiving an
1217/* entire relation, in which the descriptor is common to
1218/* all the tuples, and should not be resent or reallocated
1219/* with each one. Receive relation can send the tuple descriptor
1220/* once, then do a create_tuple followed by a decode tuple_data
1221/* to receive the tuple field data into the existing tuple.
1222/*
1223/* Note that the definition of null is different in the two cases.
1224/* The null value for a tuple is just a null pointer. The null
1225/* for tuple data is to null each of the fields in the tuple
1226/* recursively. The routines in this section may dereference
1227/* null pointers if the tuples they are passed are null. Note
1228/* also that there is one less level of indirection in passing
1229/* data to these routines than to those of tuple_t.
1230/*
1231/* Note also that the null and decode routines supplied here
1232/* presume that any fields with dependent memory (e.g. string_t
1233/* fields have already been cleaned up.)
1234/*
1235/* Note that this is not quite a kosher type, in the sense that
1236/* it's length is not fixed. The entry for length below
1237/* is meaningless, because the real length is computed from the
1238/* desc. Among other things, this means that TUPLEs cannot
1239/* contain fields of this type.
1240/*
1241/************************************************************************/
1242
1243#define TDT_LEN (sizeof(TUPLE))
1244#define TDT_ALI TDT_LEN
1245#define TDT_NULL g_tdt_null
1246#define TDT_CDLEN g_tdt_cdlen
1247#define TDT_ENC g_tdt_enc
1248#define TDT_DEC g_tdt_dec
1249#define TDT_FORM g_tdt_form
1250#define TDT_NAME "TUPLE_DATA_T"
1251
1252 /*----------------------------------------------------------*/
1253 /*
1254 /* g_tdt_null
1255 /*
1256 /* Fill in a null value for a tuple.
1257 /*
1258 /*----------------------------------------------------------*/
1259int
1260g_tdt_null(dp)
1261char *dp; /* pointer to the data */
1262{
1263 TUPLE tup = (TUPLE)dp; /* dp is of type TUPLE, */
1264 /* which is actually */
1265 /* a pointer to the */
1266 /* tuple data */
1267 TUPLE_DESCRIPTOR tpd; /* the descriptor for this */
1268 /* tuple*/
1269 register int i; /* a loop counter */
1270
1271 /*
1272 * For each field in the tuple, call its null routine
1273 */
1274 tup->id = GDB_TUP_ID;
1275
1276 tpd = DESCRIPTOR_FROM_TUPLE(tup);
1277
1278 for (i=0; i<tpd->field_count; i++) {
1279 FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),NULL_PROPERTY)
1280 (FIELD_FROM_TUPLE(tup,i));
1281 }
1282}
1283
1284 /*----------------------------------------------------------*/
1285 /*
1286 /* g_tdt_cdlen
1287 /*
1288 /* Return coded length for tuple data. Since the descriptor
1289 /* for the tuple is known at both sides, we send only
1290 /* the coded fields, not even the field counts.
1291 /*
1292 /*----------------------------------------------------------*/
1293
1294int
1295g_tdt_cdlen(dp,hcon)
1296char *dp; /* pointer to the data */
1297HALF_CONNECTION hcon;
1298{
1299 register TUPLE tup = (TUPLE)dp; /* arg typed as tuple */
1300 register int len; /* accumulated length */
1301 register int i; /* index to fields */
1302 TUPLE_DESCRIPTOR tpd; /* descriptor for this tuple */
1303
1304 /*
1305 * Validate the tuple data
1306 */
1307 if (tup == NULL)
1308 GDB_GIVEUP("g_tdt_cdlen (coded length) was given null tuple data\nthis may be due to an attempt to transmit invalid data")
1309 GDB_CHECK_TUP(tup,"g_tdt_cdlen: compute coded length of tuple data")
1310 /*
1311 * First, find the tuple descriptor and set initial coded len to 0
1312 */
1313
1314 tpd = DESCRIPTOR_FROM_TUPLE(tup);
1315 len = 0;
1316
1317 /*
1318 * Now, for each field, add in its coded length
1319 */
1320
1321 for (i=0; i<tpd->field_count; i++) {
1322 len += (int)FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),
1323 CODED_LENGTH_PROPERTY)
1324 (FIELD_FROM_TUPLE(tup, i),hcon);
1325 }
1326
1327 return len;
1328}
1329
1330 /*----------------------------------------------------------*/
1331 /*
1332 /* g_tdt_enc
1333 /*
1334 /* Encode tuple data for transmission.
1335 /*
1336 /*----------------------------------------------------------*/
1337
1338int
1339g_tdt_enc(dp, hcon, outp)
1340char *dp; /* pointer to data */
1341HALF_CONNECTION hcon; /* connection descriptor */
1342char *outp; /* place to put the output */
1343{
1344 register TUPLE tup = (TUPLE)dp; /* type as tuple */
1345 register int i; /* index to fields */
1346 TUPLE_DESCRIPTOR tpd; /* descriptor for this tuple */
1347 char *op = outp; /* next byte of output */
1348
1349 /*
1350 * Validate the tuple data
1351 */
1352 if (tup == NULL)
1353 GDB_GIVEUP("g_tdt_enc (encode) was given null tuple data\nthis may be due to an attempt to transmit invalid data")
1354 GDB_CHECK_TUP(tup,"g_tdt_enc: encode of tuple data")
1355 /*
1356 * First, get the tuple descriptor
1357 */
1358
1359 tpd = DESCRIPTOR_FROM_TUPLE(tup);
1360
1361 /*
1362 * Now, for each field, code it
1363 */
1364
1365 for (i=0; i<tpd->field_count; i++) {
1366 op = (char *)FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),
1367 ENCODE_PROPERTY)
1368 (FIELD_FROM_TUPLE(tup, i),hcon, op);
1369 }
1370
1371 return (int)op;
1372}
1373
1374 /*----------------------------------------------------------*/
1375 /*
1376 /* g_tdt_dec
1377 /*
1378 /* Decode tuple data from external form. We presume
1379 /* that the tuple itself is allocated, and the descriptor
1380 /* properly set up for the local machine representation.
1381 /* Here we just decode the fields.
1382 /*
1383 /*----------------------------------------------------------*/
1384
1385int
1386g_tdt_dec(outp, hcon, inp)
1387char *inp; /* pointer to input data */
1388HALF_CONNECTION hcon; /* connection descriptor */
1389char *outp; /* place to put the output */
1390{
1391 register TUPLE tup = (TUPLE)outp; /* the filled in tuple */
1392 register int i; /* index to fields */
1393 TUPLE_DESCRIPTOR tpd; /* descriptor for this tuple */
1394 char *ip = inp; /* next byte of input */
1395
1396 /*
1397 * Validate the tuple data
1398 */
1399 if (tup == NULL)
1400 GDB_GIVEUP("g_tdt_dec (decode) was given null tuple data\nthis may be due to an attempt to transmit invalid data")
1401 GDB_CHECK_TUP(tup,"g_tdt_dec: decode of tuple data")
1402 /*
1403 * First, get the tuple descriptor
1404 */
1405
1406 tpd = DESCRIPTOR_FROM_TUPLE(tup);
1407
1408 /*
1409 * Now, for each field, decode it.
1410 */
1411
1412 for (i=0; i<tpd->field_count; i++) {
1413 ip = (char *)FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),
1414 DECODE_PROPERTY)
1415 (FIELD_FROM_TUPLE(tup, i),hcon, ip);
1416 }
1417
1418 return (int)ip;
1419}
1420
1421 /*----------------------------------------------------------*/
1422 /*
1423 /* g_tdt_form
1424 /*
1425 /* Format tuple data on output logging file for
1426 /* debugging.
1427 /*
1428 /*----------------------------------------------------------*/
1429
1430int
1431g_tdt_form(name, dp)
1432char *name; /* tuple name of the field */
1433char *dp; /* pointer to the data */
1434{
1435 register TUPLE tup = (TUPLE)dp; /* as tuple */
1436 register int i; /* index to fields */
1437 TUPLE_DESCRIPTOR tpd; /* descriptor for this tuple */
1438
1439
1440 /*
1441 * Handle special case where we're given a null address for the
1442 * tuple
1443 */
1444 if (tup==NULL) {
1445 fprintf(gdb_log,"\nTUPLE Name=%s is NULL\n---------------------------\n",name);
1446 return;
1447 }
1448
1449
1450 /*
1451 * Validate the tuple data
1452 */
1453 GDB_CHECK_TUP(tup,"g_tdt_form: format tuple data")
1454 /*
1455 * Get the descriptor--for now, we won't print it
1456 */
1457 tpd = DESCRIPTOR_FROM_TUPLE(tup);
1458
1459 /*
1460 * Print a header
1461 */
1462
1463 fprintf(gdb_log,"\nTUPLE at address: 0x%x Name=%s\n---------------------------\n",tup,name);
1464
1465 /*
1466 * Now, for each field, print it
1467 */
1468
1469 for (i=0; i<tpd->field_count; i++) {
1470 FCN_PROPERTY(FIELD_TYPE_IN_TUPLE(tpd,i),
1471 FORMAT_PROPERTY)
1472 (tpd->var[i].name,FIELD_FROM_TUPLE(tup, i));
1473 }
1474
1475 fprintf(gdb_log,"END_OF_TUPLE\n");
1476}
1477\f
1478/************************************************************************/
1479/*
1480/* RELATION_T
1481/*
1482/* Relations consist of link lists of tuples, all of which are
1483/* presumed to share a tuple descriptor. For transmission,
1484/* these are encoded as follows:
1485/*
1486/* 1) A count of the number of tuples, sent as a properly coded
1487/* integer.
1488/*
1489/* 2) The tuple descriptor itself, encoded by its encoding routine.
1490/*
1491/* 3) For each tuple, its tuple data, encoded using the routines
1492/* of the tuple_data_t type.
1493/*
1494/************************************************************************/
1495
1496#define REL_LEN (sizeof(RELATION))
1497#define REL_ALI REL_LEN
1498#define REL_NULL g_rel_null
1499#define REL_CDLEN g_rel_cdlen
1500#define REL_ENC g_rel_enc
1501#define REL_DEC g_rel_dec
1502#define REL_FORM g_rel_form
1503#define REL_NAME "RELATION_T"
1504
1505
1506 /*----------------------------------------------------------*/
1507 /*
1508 /* g_rel_null
1509 /*
1510 /* Fill in a null value for a relation. Maybe we should
1511 /* check for an existing relation and properly free it,
1512 /* but for now, we don't.
1513 /*
1514 /*----------------------------------------------------------*/
1515int
1516g_rel_null(dp)
1517char *dp; /* pointer to the data */
1518{
1519 *((RELATION *)dp) = NULL;
1520}
1521
1522 /*----------------------------------------------------------*/
1523 /*
1524 /* g_rel_cdlen
1525 /*
1526 /* Return coded length for a relation.
1527 /*
1528 /*----------------------------------------------------------*/
1529
1530int
1531g_rel_cdlen(dp,hcon)
1532char *dp; /* pointer to the data */
1533HALF_CONNECTION hcon;
1534{
1535 register RELATION rel = *((RELATION *)dp); /* deref as relation */
1536 int len; /* accumulated length */
1537 register TUPLE t; /* index to a tuple */
1538 int tuple_count = 0; /* number of tuples in this */
1539 /* relation*/
1540 TUPLE_DESCRIPTOR tpd; /* descriptor for this */
1541 /* relation */
1542
1543 /*
1544 * Validate the relation
1545 */
1546 if (rel == NULL)
1547 GDB_GIVEUP("g_rel_cdlen (coded length) was given null relation\nthis may be due to an attempt to transmit invalid data")
1548 GDB_CHECK_REL(rel,"g_rel_cdlen: compute coded length of relation")
1549 /*
1550 * First, get the tuple descriptor for this relation
1551 */
1552
1553 tpd = DESCRIPTOR_FROM_RELATION(rel);
1554
1555 /*
1556 * Count the number of tuples in the relation
1557 */
1558 for (t=FIRST_TUPLE_IN_RELATION(rel); t != NULL;
1559 t = NEXT_TUPLE_IN_RELATION(rel,t))
1560 tuple_count++;
1561 /*
1562 * Start with the coded length for the tuple count and the
1563 * descriptor, which are sent first.
1564 */
1565
1566 len = g_in_cdlen((char *)&tuple_count, hcon); /* length of tuple_count */
1567 /* in coded form */
1568 len += g_tpd_cdlen((char *)&tpd, hcon);
1569
1570 /*
1571 * Now, for each tuple, add in its coded length
1572 */
1573
1574 for (t=FIRST_TUPLE_IN_RELATION(rel); t != NULL;
1575 t = NEXT_TUPLE_IN_RELATION(rel,t))
1576 len += g_tdt_cdlen((char *)t, hcon);
1577
1578 return len;
1579}
1580
1581 /*----------------------------------------------------------*/
1582 /*
1583 /* g_rel_enc
1584 /*
1585 /* Encode a relation for transmission
1586 /*
1587 /*----------------------------------------------------------*/
1588
1589int
1590g_rel_enc(dp, hcon, outp)
1591char *dp; /* pointer to data */
1592HALF_CONNECTION hcon; /* connection descriptor */
1593char *outp; /* place to put the output */
1594{
1595 register RELATION rel = *((RELATION *)dp); /* deref as relation */
1596 char *op; /* pointer to next unused */
1597 /* output byte*/
1598 register TUPLE t; /* index to a tuple */
1599 int tuple_count = 0; /* number of tuples in this */
1600 /* relation*/
1601 TUPLE_DESCRIPTOR tpd; /* descriptor for this */
1602 /* relation */
1603
1604 /*
1605 * Validate the relation
1606 */
1607 if (rel == NULL)
1608 GDB_GIVEUP("g_rel_enc (encode) was given null relation\nthis may be due to an attempt to transmit invalid data")
1609 GDB_CHECK_REL(rel,"g_rel_enc: encode relation")
1610
1611 /*
1612 * First, get the tuple descriptor for this relation
1613 */
1614
1615 tpd = DESCRIPTOR_FROM_RELATION(rel);
1616
1617 /*
1618 * Count the number of tuples in the relation
1619 */
1620 for (t=FIRST_TUPLE_IN_RELATION(rel); t != NULL;
1621 t = NEXT_TUPLE_IN_RELATION(rel,t))
1622 tuple_count++;
1623 /*
1624 * Encode the count and the tuple descriptor for this relation
1625 */
1626
1627 op = (char *)g_in_enc((char *)&tuple_count, hcon,outp);
1628 /* length of tuple_count */
1629 /* in coded form */
1630 op = (char *)g_tpd_enc((char *)&tpd, hcon,op);
1631
1632 /*
1633 * Now, encode each tuple
1634 */
1635
1636 for (t=FIRST_TUPLE_IN_RELATION(rel); t != NULL;
1637 t = NEXT_TUPLE_IN_RELATION(rel,t))
1638 op = (char *)g_tdt_enc((char *)t, hcon, op);
1639
1640 return (int)op;
1641}
1642
1643 /*----------------------------------------------------------*/
1644 /*
1645 /* g_rel_dec
1646 /*
1647 /* Decode a relation from external form. We should
1648 /* really check to make sure the relation we are given
1649 /* is null, and if not, call delete_relation on it
1650 /* first. For the moment, we just presume it's null.
1651 /*
1652 /* We proceed by decoding the integer count and the
1653 /* tuple descriptor, from which we create the null
1654 /* relation. We then loop for each tuple, doing a
1655 /* create, a decode, and an add to relation.
1656 /*
1657 /*----------------------------------------------------------*/
1658
1659int
1660g_rel_dec(outp, hcon, inp)
1661char *inp; /* pointer to input data */
1662HALF_CONNECTION hcon; /* connection descriptor */
1663char *outp; /* place to put the output */
1664{
1665 register RELATION rel; /* build the relation here */
1666 char *ip; /* pointer to next unused */
1667 /* input byte*/
1668 register TUPLE t; /* index to a tuple */
1669 register int i; /* loop counter on tuples */
1670 int tuple_count = 0; /* number of tuples in this */
1671 /* relation*/
1672 TUPLE_DESCRIPTOR tpd; /* descriptor for this */
1673 /* relation */
1674
1675 /*
1676 * First, get the field count and tuple descriptor for this relation
1677 */
1678
1679 ip = (char *)g_in_dec((char *)&tuple_count, hcon, inp);
1680
1681 tpd = NULL; /* so decode will know */
1682 /* there's no existing one */
1683 /* to free */
1684 ip = (char *)g_tpd_dec((char *)&tpd, hcon, ip);
1685
1686 /*
1687 * Now, create a null relation using the descriptor
1688 */
1689
1690 rel = create_relation(tpd);
1691
1692 /*
1693 * The reference count for the tuple descriptor is currently 2,
1694 * one from the tpd_dec and one from the create relation. Since
1695 * these will not be undone separately, we decrement the reference
1696 * count to 1
1697 */
1698
1699 UNREFERENCE_TUPLE_DESCRIPTOR(tpd);
1700
1701 /*
1702 * For each tuple, create it, receive it, add it to the relation
1703 */
1704
1705 for (i=0; i<tuple_count; i++) {
1706 t = create_tuple(tpd);
1707 ip = (char *)g_tdt_dec((char *)t, hcon, ip);
1708 ADD_TUPLE_TO_RELATION(rel, t);
1709 }
1710
1711 /*
1712 * Now store the address of the created relation where requested
1713 * and return pointer to next available input byte.
1714 */
1715
1716 *((RELATION *)outp) = rel;
1717
1718 return (int)ip;
1719}
1720
1721 /*----------------------------------------------------------*/
1722 /*
1723 /* g_rel_form
1724 /*
1725 /* Format a relation on output logging file for
1726 /* debugging.
1727 /*
1728 /*----------------------------------------------------------*/
1729
1730int
1731g_rel_form(name, dp)
1732char *name; /* relation name of the field */
1733char *dp; /* pointer to the data */
1734{
1735 register RELATION rel = *((RELATION *)dp); /* deref as relation */
1736 register TUPLE t;
1737 int count =0;
1738 char buffer[50];
1739
1740 /*
1741 * Handle special case where relation is null
1742 */
1743
1744 if (rel == NULL) {
1745 fprintf(gdb_log,"\nRELATION Name=%s is NULL\n===========================\n",name);
1746 return;
1747 }
1748
1749 GDB_CHECK_REL(rel,"g_rel_form: format relation")
1750
1751 /*
1752 * Print a header
1753 */
1754
1755 fprintf(gdb_log,"\nRELATION at address: 0x%x Name=%s\n===========================\n",rel,name);
1756
1757 /*
1758 * Now, for each field, print it
1759 */
1760
1761 for (t=FIRST_TUPLE_IN_RELATION(rel); t != NULL;
1762 t = NEXT_TUPLE_IN_RELATION(rel,t)){
1763 (void) sprintf(buffer,"Number %d",++count);
1764 g_tdt_form(buffer,(char *)t);
1765 }
1766
1767 fprintf(gdb_log,"END_OF_RELATION\n");
1768}
1769\f
1770/************************************************************************/
1771/*
1772/* DECLARE AND INITIALIZE THE SYSTEM TYPE DEFINITION
1773/* TABLES
1774/*
1775/* This representation is clearly a real pain to keep up to date
1776/* properly, mostly because C has such a lousy pre-processor.
1777/* Probably this should be re-arranged so an initialization routine
1778/* is called to set up the tables, but even that might be a nuissance.
1779/*
1780/************************************************************************/
1781
1782 /*----------------------------------------------------------*/
1783 /*
1784 /* gdb_i_stype
1785 /*
1786 /* Called at startup to initialize the type table with
1787 /* the entries for the system types.
1788 /*
1789 /*----------------------------------------------------------*/
1790
1791#define ITYPE(inx,lp,ap,np,clp,ep,dp,fp,name) {\
1792 g_type_table[inx][LENGTH_PROPERTY].i = lp; \
1793 g_type_table[inx][ALIGNMENT_PROPERTY].i = ap; \
1794 g_type_table[inx][NULL_PROPERTY].f = np; \
1795 g_type_table[inx][CODED_LENGTH_PROPERTY].f = clp; \
1796 g_type_table[inx][ENCODE_PROPERTY].f = ep; \
1797 g_type_table[inx][DECODE_PROPERTY].f = dp; \
1798 g_type_table[inx][FORMAT_PROPERTY].f = fp; \
1799 g_type_table[inx][NAME_PROPERTY].cp = name; \
1800}
1801
1802int
1803gdb_i_stype()
1804{
1805 gdb_n_types = SYSTEM_TYPE_COUNT;
1806
1807 ITYPE(INTEGER_T,IN_LEN,IN_ALI,IN_NULL,IN_CDLEN,IN_ENC,IN_DEC,IN_FORM,
1808 IN_NAME)
1809 ITYPE(STRING_T,ST_LEN,ST_ALI,ST_NULL,ST_CDLEN,ST_ENC,ST_DEC,ST_FORM,
1810 ST_NAME)
1811 ITYPE(REAL_T,RL_LEN,RL_ALI,RL_NULL,RL_CDLEN,RL_ENC,RL_DEC,RL_FORM,
1812 RL_NAME)
1813 ITYPE(DATE_T,DT_LEN,DT_ALI,DT_NULL,DT_CDLEN,DT_ENC,DT_DEC,DT_FORM,
1814 DT_NAME)
1815 ITYPE(TUPLE_DESCRIPTOR_T,TPD_LEN,TPD_ALI,TPD_NULL,TPD_CDLEN,TPD_ENC,
1816 TPD_DEC,TPD_FORM,TPD_NAME)
1817 ITYPE(TUPLE_T,TP_LEN,TP_ALI,TP_NULL,TP_CDLEN,TP_ENC,TP_DEC,TP_FORM,
1818 TP_NAME)
1819 ITYPE(TUPLE_DATA_T,TDT_LEN,TDT_ALI,TDT_NULL,TDT_CDLEN,TDT_ENC,TDT_DEC,
1820 TDT_FORM,TDT_NAME)
1821 ITYPE(RELATION_T,REL_LEN,REL_ALI,REL_NULL,REL_CDLEN,REL_ENC,REL_DEC,
1822 REL_FORM,REL_NAME)
1823}
This page took 0.312002 seconds and 5 git commands to generate.