Initial import of the CDE 2.1.30 sources from the Open Group.

cde/lib/csa/convert4-3.c

@@ -0,0 +1,747 @@
+/* $XConsortium: convert4-3.c /main/1 1996/04/21 19:22:43 drk $ */
+/*
+ *  (c) Copyright 1993, 1994 Hewlett-Packard Company
+ *  (c) Copyright 1993, 1994 International Business Machines Corp.
+ *  (c) Copyright 1993, 1994 Novell, Inc.
+ *  (c) Copyright 1993, 1994 Sun Microsystems, Inc.
+ */
+
+#include <EUSCompat.h>
+#include <malloc.h>
+#include <string.h>
+#include <stdlib.h>
+#include "rtable3.h"
+#include "rtable4.h"
+#include "convert4-3.h"
+
+/*
+ * forward declaration of static functions
+ */
+static void free_excpt3(Except_3 *e);
+static Abb_Appt_3 * abb4_to_abb3(Abb_Appt_4 *a4);
+static void apptid4_to_apptid3(Apptid_4 *from, Apptid_3 *to);
+static Reminder_3 * reminder4_to_reminder3(Reminder_4 *r4);
+static Table_Res_Type_3 tablerestype4_to_tablerestype3(Table_Res_Type_4 t);
+static void tablereslist4_to_tablereslist3(Table_Res_List_4 *from,
+		Table_Res_List_3 *to);
+static void period4_to_period3(Period_4 *p4, Period_3 *p3);
+static void assign_tag4to3(Tag_4 *t4, Tag_3 *t3);
+static void assign_status4to3(Appt_Status_4 *s4, Appt_Status_3 *s3);
+static void assign_privacy4to3(Privacy_Level_4 *p4, Privacy_Level_3 *p3);
+static Buffer_3 buffer4_to_buffer3(Buffer_4 b);
+static Tag_3 * tag4_to_tag3(Tag_4 *t4);
+static Attribute_3 * attr4_to_attr3(Attribute_4 *a4);
+static Except_3 * except4_to_except3(Except_4 *e4);
+static Table_Args_Type_3 argstag4_to_argstag3(Table_Args_Type_4 t);
+static void args4_to_args3(Args_4 *from, Args_3 *to);
+static Table_Args_3 * tableargs4_to_tableargs3(Table_Args_4 *a4);
+static Registration_3 * reg4_to_reg3(Registration_4 *r4);
+static void free_tag3(Tag_3 *t);
+
+/**************** DATA TYPE (4->3) CONVERSION ROUTINES **************/
+
+extern void
+_DtCm_id4_to_id3(Id_4 *from, Id_3 *to)
+{
+        if ((from==NULL) || (to==NULL)) return;	
+        to->tick = from->tick;
+        to->key = from->key;
+}
+
+extern Uid_3 *
+_DtCm_uid4_to_uid3(Uid_4 *ui4)
+{
+        Uid_3 *ui3, *head, *prev;
+
+	prev = head = NULL;
+	while (ui4 != NULL) {
+		ui3 = (Uid_3 *)calloc(1, sizeof(Uid_3));
+		_DtCm_id4_to_id3(&(ui4->appt_id), &(ui3->appt_id));
+		ui3->next = NULL;
+
+		if (head == NULL)
+			head = ui3;
+		else
+			prev->next = ui3;
+		prev = ui3;
+
+		ui4 = ui4->next;
+	}
+	return(head);
+}
+
+extern Appt_3 *
+_DtCm_appt4_to_appt3(Appt_4 *a4)
+{
+        Appt_3 *a3, *head, *prev;
+
+	prev = head = NULL;
+	while (a4 != NULL) {
+		a3  = (Appt_3 *)calloc(1, sizeof(Appt_3));
+		_DtCm_id4_to_id3(&(a4->appt_id), &(a3->appt_id));
+		a3->tag = tag4_to_tag3(a4->tag);
+		a3->duration = a4->duration;
+		a3->ntimes = a4->ntimes;
+		a3->what = buffer4_to_buffer3(a4->what);
+		period4_to_period3(&(a4->period), &(a3->period));
+		a3->author = buffer4_to_buffer3(a4->author);
+		a3->client_data = buffer4_to_buffer3(a4->client_data);
+		a3->exception = except4_to_except3(a4->exception);
+		a3->attr = attr4_to_attr3(a4->attr);
+		assign_status4to3(&a4->appt_status, &a3->appt_status);
+		assign_privacy4to3(&a4->privacy, &a3->privacy);
+		a3->next = NULL;
+
+		if (head == NULL)
+			head = a3;
+		else
+			prev->next = a3;
+		prev = a3;
+
+		a4 = a4->next;
+	}
+	return(head);
+}
+
+extern void
+_DtCm_free_appt3(Appt_3 *a)
+{
+	Appt_3 *ptr;
+
+	while (a != NULL) {
+		ptr = a->next;
+
+		if (a->tag != NULL)
+			free_tag3(a->tag);
+
+		if (a->what != NULL)
+			free(a->what);
+
+		if (a->author != NULL)
+			free(a->author);
+
+		if (a->client_data != NULL)
+			free(a->client_data);
+
+		if (a->attr != NULL)
+			_DtCm_free_attr3(a->attr);
+
+		if (a->exception != NULL)
+			free_excpt3(a->exception);
+
+     		free(a);
+
+		a = ptr;
+	}
+}
+
+extern void
+_DtCm_free_attr3(Attribute_3 *a)
+{
+	Attribute_3 *ptr;
+
+	while (a != NULL) {
+		ptr = a->next;
+		if (a->attr != NULL)
+			free(a->attr);
+		if (a->value != NULL)
+			free(a->value);
+		if (a->clientdata != NULL)
+			free(a->clientdata);
+		free(a);
+
+		a = ptr;
+	}
+}
+
+static void
+free_excpt3(Except_3 *e)
+{
+	Except_3 *ptr;
+
+	while (e != NULL) {
+		ptr = e->next;
+		free(e);
+		e = ptr;
+	}
+}
+
+static Abb_Appt_3 *
+abb4_to_abb3(Abb_Appt_4 *a4)
+{
+        Abb_Appt_3 *a3, *head, *prev;
+
+	prev = head = NULL;
+	while (a4 != NULL) {
+		a3 = (Abb_Appt_3 *)calloc(1, sizeof(Abb_Appt_3));
+		_DtCm_id4_to_id3(&(a4->appt_id), &(a3->appt_id));
+		a3->tag = tag4_to_tag3(a4->tag);
+		a3->what = buffer4_to_buffer3(a4->what);
+		a3->duration = a4->duration;
+		period4_to_period3(&(a4->period), &(a3->period));
+		assign_status4to3(&a4->appt_status, &a3->appt_status);
+		assign_privacy4to3(&a4->privacy, &a3->privacy);
+		a3->next = NULL;
+
+		if (head == NULL)
+			head = a3;
+		else
+			prev->next = a3;
+		prev = a3;
+
+		a4 = a4->next;
+	}
+	return(head);
+}
+
+static void
+apptid4_to_apptid3(Apptid_4 *from, Apptid_3 *to)
+{
+        if (from==NULL || to==NULL) return;
+        _DtCm_id4_to_id3(from->oid, to->oid);
+        to->new_appt = _DtCm_appt4_to_appt3(from->new_appt);
+}
+
+static Reminder_3 *
+reminder4_to_reminder3(Reminder_4 *r4)
+{
+        Reminder_3 *r3, *head, *prev;
+	Attribute_3 *attr3;
+
+	prev = head = NULL;
+	while (r4 != NULL) {
+		r3 = (Reminder_3 *)calloc(1, sizeof(Reminder_3));
+		_DtCm_id4_to_id3(&(r4->appt_id), &(r3->appt_id));
+		r3->tick = r4->tick;
+		attr3 = attr4_to_attr3(&(r4->attr));
+		r3->attr = *attr3;
+		free(attr3);
+		r3->next = NULL;
+
+		if (head == NULL)
+			head = r3;
+		else
+			prev->next = r3;
+		prev = r3;
+
+		r4 = r4->next;
+	}
+	return(head);
+}
+
+static Table_Res_Type_3
+tablerestype4_to_tablerestype3(Table_Res_Type_4 t)
+{
+	switch(t) {
+	case AP_4:
+		return(AP_3);
+	case RM_4:
+		return(RM_3);
+	case AB_4:
+		return(AB_3);
+	case ID_4:
+		return(ID_3);
+	default:
+		return(AP_3);
+	}
+}
+
+static void
+tablereslist4_to_tablereslist3(Table_Res_List_4 *from, Table_Res_List_3 *to)
+{
+        if (from==NULL || to==NULL) return;
+        to->tag = tablerestype4_to_tablerestype3(from->tag);
+        switch (from->tag) {
+        case AP_4:
+                to->Table_Res_List_3_u.a = _DtCm_appt4_to_appt3(
+                        from->Table_Res_List_4_u.a);
+                break;
+        case RM_4:
+                to->Table_Res_List_3_u.r = reminder4_to_reminder3(
+                        from->Table_Res_List_4_u.r);
+                break;
+        case AB_4:
+                to->Table_Res_List_3_u.b = abb4_to_abb3(
+                        from->Table_Res_List_4_u.b);
+                break;
+        case ID_4:
+                to->Table_Res_List_3_u.i = _DtCm_uid4_to_uid3(
+                        from->Table_Res_List_4_u.i);
+        default:
+                return;
+        }
+}
+ 
+extern Access_Status_3
+_DtCm_accstat4_to_accstat3(Access_Status_4 s)
+{
+	switch(s) {
+	case access_ok_4:
+		return(access_ok_3);
+	case access_added_4:
+		return(access_added_3);
+	case access_removed_4:
+		return(access_removed_3);
+	case access_failed_4:
+		return(access_failed_3);
+	case access_exists_4:
+		return(access_exists_3);
+	case access_partial_4:
+		return(access_partial_3);
+	case access_other_4:
+	default:
+		return(access_other_3);
+	}
+}
+
+extern Table_Res_3 *
+_DtCm_tableres4_to_tableres3(Table_Res_4 *r4)
+{
+        Table_Res_3 *r3;
+
+	if (r4==NULL) return((Table_Res_3 *)NULL);
+	r3 = (Table_Res_3 *)calloc(1, sizeof(Table_Res_3));
+        r3->status = _DtCm_accstat4_to_accstat3(r4->status);
+        tablereslist4_to_tablereslist3(&(r4->res), &(r3->res));
+        return(r3);
+}
+
+extern Access_Entry_3 *
+_DtCm_acclist4_to_acclist3(Access_Entry_4 *l4)
+{
+        Access_Entry_3 *l3, *head, *prev;
+
+	prev = head = NULL;
+	while (l4 != NULL) {
+		l3 = (Access_Entry_3 *)calloc(1, sizeof(Access_Entry_3));
+		l3->who = buffer4_to_buffer3(l4->who);
+		l3->access_type = l4->access_type;
+		l3->next = NULL;
+
+		if (head == NULL)
+			head = l3;
+		else
+			prev->next = l3;
+		prev = l3;
+
+		l4 = l4->next;
+	}
+	return(head);
+}
+ 
+extern Access_Args_3 *
+_DtCm_accargs4_to_accargs3(Access_Args_4 *a4)
+{
+        Access_Args_3 *a3;
+
+	if (a4==NULL) return((Access_Args_3 *)NULL);
+	a3 = (Access_Args_3 *)calloc(1, sizeof(Access_Args_3));
+        a3->target = buffer4_to_buffer3(a4->target);
+        a3->access_list = _DtCm_acclist4_to_acclist3(a4->access_list);
+        return(a3);
+}
+
+extern Range_3 *
+_DtCm_range4_to_range3(Range_4 *r4)
+{
+	Range_3 *r3, *head, *prev;
+
+	prev = head = NULL;
+	while (r4 != NULL) {
+		r3 = (Range_3 *)calloc(1, sizeof(Range_3));
+		r3->key1 = r4->key1;
+		r3->key2 = r4->key2;
+		r3->next = NULL;
+
+		if (head == NULL)
+			head = r3;
+		else
+			prev->next = r3;
+		prev = r3;
+
+		r4 = r4->next;
+	}
+	return(head);
+}
+
+extern Keyrange_3 *
+_DtCm_keyrange4_to_keyrange3(Keyrange_4 *r4)
+{
+        Keyrange_3 *r3, *head, *prev;
+ 
+	prev = head = NULL;
+	while (r4 != NULL) {
+		r3 = (Keyrange_3 *)calloc(1, sizeof(Keyrange_3));
+		r3->key = r4->key;
+		r3->tick1 = r4->tick1;
+		r3->tick2 = r4->tick2;
+		r3->next = NULL;
+
+		if (head == NULL)
+			head = r3;
+		else
+			prev->next = r3;
+		prev = r3;
+
+		r4 = r4->next;
+	}
+	return(head);
+}
+
+extern Registration_Status_3 
+_DtCm_regstat4_to_regstat3(Registration_Status_4 s)
+{
+	switch (s) {
+	case registered_4:
+		return(registered_3);
+	case failed_4:
+		return(failed_3);
+	case deregistered_4:
+		return(deregistered_3);
+	case confused_4:
+		return(confused_3);
+	case reg_notable_4:
+	default:
+		return(failed_3);
+	}
+}
+
+extern Table_Status_3
+_DtCm_tablestat4_to_tablestat3(Table_Status_4 s)
+{
+	switch(s) {
+	case ok_4:
+		return(ok_3);
+	case duplicate_4:
+		return(duplicate_3);
+	case badtable_4:
+		return(badtable_3);
+	case notable_4:
+		return(notable_3);
+	case denied_4:
+		return(denied_3);
+	case other_4:
+	default:
+		return(other_3);
+	}
+}
+
+extern Uid_3 *
+_DtCm_uidopt4_to_uid3(Uidopt_4 *uidopt)
+{
+        Uid_3 *uid3, *head, *prev;
+ 
+	prev = head = NULL;
+	while (uidopt != NULL) {
+        	uid3 = (Uid_3 *)calloc(1, sizeof(Uid_3));
+        	_DtCm_id4_to_id3(&(uidopt->appt_id), &(uid3->appt_id));
+        	uid3->next = NULL;
+
+		if (head == NULL)
+			head = uid3;
+		else
+			prev->next = uid3;
+		prev = uid3;
+
+		uidopt = uidopt->next;
+	}
+	return(head);
+}
+ 
+/*
+ * Repeating event types beyond "yearly" are mapped to "single"
+ * because the old front end does not recognize any other types
+ * Worse yet it uses Interval to index into an array which
+ * contains strings up to "yearly", any period types beyond that
+ * would index beyond the array and cause the front end to dump core.
+ */
+static void
+period4_to_period3(Period_4 *p4, Period_3 *p3)
+{
+	if (p3 == NULL || p4 == NULL) return;
+
+        switch (p4->period) {
+ 
+        case single_4: 	p3->period = single_3;
+			p3->nth = p4->nth;
+                        break;
+ 
+        case daily_4: 	p3->period = daily_3;
+			p3->nth = p4->nth;
+                        break;
+ 
+        case weekly_4: 	p3->period = weekly_3;
+			p3->nth = p4->nth;
+                        break;
+ 
+        case biweekly_4: p3->period = biweekly_3;
+			p3->nth = p4->nth;
+                        break;
+ 
+        case monthly_4: p3->period = monthly_3;
+			p3->nth = p4->nth;
+                        break;
+ 
+        case yearly_4: 	p3->period = yearly_3;
+			p3->nth = p4->nth;
+                        break;
+
+	default: p3->period = single_3;
+		 p3->nth = 0;
+			break;
+        }
+}
+
+ 
+static void
+assign_tag4to3(Tag_4 *t4, Tag_3 *t3)
+{
+        switch (t4->tag) {
+ 
+        case appointment_4: t3->tag = appointment_3;
+                        break;
+ 
+        case reminder_4: t3->tag = reminder_3;
+                        break;
+ 
+        case otherTag_4: t3->tag = otherTag_3;
+                        break;
+ 
+        case holiday_4: t3->tag = holiday_3;
+                        break;
+ 
+        case toDo_4: t3->tag = toDo_3;
+                        break;
+        }
+}
+
+ 
+static void
+assign_status4to3(Appt_Status_4 *s4, Appt_Status_3 *s3)
+{
+        switch (*s4) {
+ 
+        case active_4: *s3 = active_3;
+                        break;
+ 
+        case pendingAdd_4: *s3 = pendingAdd_3;
+                        break;
+ 
+        case pendingDelete_4: *s3 = pendingDelete_3;
+                        break;
+ 
+        case committed_4: *s3 = committed_3;
+                        break;
+ 
+        case cancelled_4: *s3 = cancelled_3;
+                        break;
+ 
+        case completed_4: *s3 = completed_3;
+                        break;
+        }
+}
+
+ 
+static void
+assign_privacy4to3(Privacy_Level_4 *p4, Privacy_Level_3 *p3)
+{
+        switch (*p4) {
+ 
+        case public_4: *p3 = public_3;
+                        break;
+ 
+        case private_4: *p3 = private_3;
+                        break;
+ 
+        case semiprivate_4: *p3 = semiprivate_3;
+                        break;
+        }
+}
+
+
+
+
+static Buffer_3
+buffer4_to_buffer3(Buffer_4 b)
+{
+	Buffer_3 copy;
+	if (b!=NULL)
+		copy = strdup(b);
+	else
+		copy = calloc(1, 1);
+	return(copy);
+}
+
+static Tag_3 *
+tag4_to_tag3(Tag_4 *t4)
+{
+	Tag_3 *t3, *head, *prev;
+
+	prev = head = NULL;
+	while (t4 != NULL) {
+		t3 = (Tag_3 *)calloc(1, sizeof(Tag_3));
+		assign_tag4to3(t4, t3);
+		t3->showtime = t4->showtime;
+		t3->next = NULL;
+
+		if (head == NULL)
+			head = t3;
+		else
+			prev->next = t3;
+		prev = t3;
+
+		t4 = t4->next;
+	}
+	return(head);
+}
+
+static Attribute_3 *
+attr4_to_attr3(Attribute_4 *a4)
+{
+        Attribute_3 *a3, *head, *prev;
+ 
+	prev = head = NULL;
+	while (a4 != NULL) {
+		a3 = (Attribute_3 *)calloc(1, sizeof(Attribute_3));
+		a3->next = NULL;
+		a3->attr = buffer4_to_buffer3(a4->attr);
+		a3->value = buffer4_to_buffer3(a4->value);
+		a3->clientdata = buffer4_to_buffer3(a4->clientdata);
+
+		if (head == NULL)
+			head = a3;
+		else
+			prev->next = a3;
+		prev = a3;
+
+		a4 = a4->next;
+	}
+	return(head);
+}
+
+static Except_3 *
+except4_to_except3(Except_4 *e4)
+{
+        Except_3 *e3, *head, *prev;
+
+	prev = head = NULL;
+	while (e4 != NULL) {
+		e3 = (Except_3 *)calloc(1, sizeof(Except_3));
+		e3->ordinal = e4->ordinal;
+		e3->next=NULL;
+
+		if (head == NULL)
+			head = e3;
+		else
+			prev->next = e3;
+		prev = e3;
+
+		e4 = e4->next;
+	}
+	return(head);
+}
+ 
+static Table_Args_Type_3
+argstag4_to_argstag3(Table_Args_Type_4 t)
+{
+        switch(t) {
+        case TICK_4:
+                return(TICK_3);
+        case APPTID_4:
+                return(APPTID_3);
+        case UID_4:
+                return(UID_3);
+        case APPT_4:
+                return(APPT_3);
+        case RANGE_4:
+                return(RANGE_3);
+	case KEYRANGE_4:
+		return(KEYRANGE_3);
+        default:
+                return(TICK_3);
+        }
+}
+
+static void
+args4_to_args3(Args_4 *from, Args_3 *to)
+{
+	if (from==NULL || to==NULL) return;
+	to->tag = argstag4_to_argstag3(from->tag);
+	switch(from->tag) {
+	case TICK_4:
+		to->Args_3_u.tick = from->Args_4_u.tick;
+		break;
+	case APPTID_4:
+		to->Args_3_u.apptid.oid = (Id_3 *)calloc(1, sizeof(Id_3));
+		apptid4_to_apptid3(
+			&(from->Args_4_u.apptid),
+			&(to->Args_3_u.apptid));
+		break;
+	case UID_4:
+		to->Args_3_u.key = _DtCm_uid4_to_uid3(from->Args_4_u.key);
+		break;
+	case APPT_4:
+		to->Args_3_u.appt = _DtCm_appt4_to_appt3(from->Args_4_u.appt);
+		break;
+	case RANGE_4:
+		to->Args_3_u.range = _DtCm_range4_to_range3(from->Args_4_u.range);
+		break;
+	case KEYRANGE_4:
+		to->Args_3_u.keyrange = _DtCm_keyrange4_to_keyrange3(
+			from->Args_4_u.keyrange);
+	default:
+		break;
+	}
+}
+
+static Table_Args_3 *
+tableargs4_to_tableargs3(Table_Args_4 *a4)
+{
+	Table_Args_3 *a3;
+	
+	if (a4==NULL) return((Table_Args_3 *)NULL);
+	a3 = (Table_Args_3 *)calloc(1, sizeof(Table_Args_3));
+	a3->target = buffer4_to_buffer3(a4->target);
+	args4_to_args3(&(a4->args), &(a3->args));
+	a3->pid = a4->pid;
+	return(a3);
+}
+
+static Registration_3 *
+reg4_to_reg3(Registration_4 *r4)
+{
+        Registration_3 *r3, *head, *prev;
+
+	prev = head = NULL;
+	while (r4 != NULL) {
+		r3 = (Registration_3 *)calloc(1, sizeof(Registration_3));
+		r3->target = buffer4_to_buffer3(r4->target);
+		r3->prognum = r4->prognum;
+		r3->versnum = r4->versnum;
+		r3->procnum = r4->procnum;
+		r3->next = NULL;
+		r3->pid = r4->pid;
+
+		if (head == NULL)
+			head = r3;
+		else
+			prev->next = r3;
+		prev = r3;
+
+		r4 = r4->next;
+	}
+	return(head);
+}
+
+static void
+free_tag3(Tag_3 *t)
+{
+	Tag_3 *ptr;
+
+	while (t != NULL) {
+		ptr = t->next;
+		free(t);
+		t = ptr;
+	}
+}
+