1 /******************************************************************
2 * $Id: obj.c,v 1.4 2004/10/15 13:35:39 snowdrop Exp $
3 *
4 * CSOAP Project: A SOAP client/server library in C
5 * Copyright (C) 2003 Ferhat Ayaz
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
21 *
22 * Email: ayaz@jprogrammer.net
23 ******************************************************************/
24 #include "obj.h"
25 #include "tr.h"
26 #include "util.h"
27
28 #include <stdio.h>
29 #include <string.h>
30
31 struct tagObjRegistry
32 {
33 HCOMPLEXTYPE head;
34 HCOMPLEXTYPE tail;
35 }objRegistry;
36
37
38 static HFIELD fieldCreate(const char* name, const char* type, int flag, int mino, int maxo, HCOMPLEXTYPE parentObj);
39 static void fieldFree(HFIELD field);
40 static void objAddField(HCOMPLEXTYPE obj, HFIELD field);
41 static void objFreeComplexType(HCOMPLEXTYPE obj);
42 static void objRegistryAddComplexType(HCOMPLEXTYPE obj);
43
44 static char *targetNS = NULL;
45 static int _objInitialized = 0;
46
47 /* ------------------------------------------------------------------ */
48
objInitModule(const char * tns)49 void objInitModule(const char* tns)
50 {
51 if (tns != NULL) {
52 targetNS = (char*)malloc(strlen(tns)+1);
53 strcpy(targetNS, tns);
54 }
55 if (_objInitialized) return;
56
57 objRegistry.head = NULL;
58 objRegistry.tail = NULL;
59 _objInitialized = 1;
60 }
61
objFreeModule()62 void objFreeModule()
63 {
64 HCOMPLEXTYPE cur;
65
66 cur = objRegistry.head;
67 while (cur != NULL)
68 {
69 objFreeComplexType(cur);
70 cur = cur->next;
71 }
72
73 free(targetNS);
74 }
75
76
objCreateComplexType(const char * typename)77 HCOMPLEXTYPE objCreateComplexType(const char* typename)
78 {
79 HCOMPLEXTYPE ct;
80 char buf[1054];
81
82 ct = (HCOMPLEXTYPE)malloc(sizeof(struct COMPLEXTYPE));
83 ct->type = (char*)malloc(strlen(typename)+1);
84 strcpy(ct->type, typename);
85 ct->head = ct->tail = NULL;
86 ct->next = NULL;
87 ct->base_type = NULL;
88 ct->restriction = NULL;
89 ct->isSimpleContent = 0;
90 strcpy(ct->targetNS, targetNS);
91 sprintf(ct->fullName, "%s:%s", targetNS, typename);
92 objRegistryAddComplexType(ct);
93
94 sprintf(buf, "struct %s*", typename);
95 trRegisterTypeNS(targetNS, typename, buf, 0);
96 sprintf(buf, "struct %s_List*", typename);
97 trRegisterListTypeNS(targetNS, typename, buf);
98 return ct;
99 }
100
objAddElement(HCOMPLEXTYPE obj,const char * name,const char * type,int flag,int mino,int maxo)101 HFIELD objAddElement(HCOMPLEXTYPE obj, const char* name, const char* type, int flag, int mino, int maxo)
102 {
103 HFIELD field;
104
105 field = fieldCreate(name, type, flag, mino, maxo, obj);
106 objAddField(obj, field);
107
108 return field;
109 }
110
objAddAttribute(HCOMPLEXTYPE obj,const char * name,const char * type,int flag)111 HFIELD objAddAttribute(HCOMPLEXTYPE obj, const char* name, const char* type, int flag)
112 {
113 char buffer[1054];
114 HFIELD field;
115
116 sprintf(buffer, "attr_%s", name);
117
118 field = fieldCreate(buffer, type, flag, 1, 1, obj);
119 field->attrName = (char*)malloc(strlen(name)+1);
120 strcpy(field->attrName, name);
121
122 objAddField(obj, field);
123
124 return field;
125 }
126
objSetBaseType(HCOMPLEXTYPE obj,const char * typename)127 void objSetBaseType(HCOMPLEXTYPE obj, const char* typename)
128 {
129 if (obj->base_type != NULL) free(obj->base_type);
130 obj->base_type = (char*)malloc(strlen(typename)+1);
131 strcpy(obj->base_type, typename);
132 }
133
objRegistryGetComplexType(const char * typename)134 HCOMPLEXTYPE objRegistryGetComplexType(const char* typename)
135 {
136 HCOMPLEXTYPE cur;
137
138 cur = objRegistry.head;
139 while (cur != NULL)
140 {
141 if (!strcmp(cur->fullName, typename))
142 return cur;
143 cur = cur->next;
144 }
145 return NULL;
146 }
147
148
objRegistryEnumComplexType(CT_ENUM callback)149 void objRegistryEnumComplexType(CT_ENUM callback)
150 {
151 HCOMPLEXTYPE cur;
152
153 cur = objRegistry.head;
154 while (cur != NULL)
155 {
156 if (!callback(cur)) return;
157 cur = cur->next;
158 }
159 }
160
161
162 /* ========================================================================= */
163
164 static
fieldCreate(const char * name,const char * type,int flag,int mino,int maxo,HCOMPLEXTYPE parentObj)165 HFIELD fieldCreate(const char* name, const char* type, int flag, int mino, int maxo, HCOMPLEXTYPE parentObj)
166 {
167 HFIELD field;
168
169 field = (HFIELD)malloc(sizeof(struct FIELD));
170 field->name = (char*)malloc(strlen(name)+1);
171 field->type = (char*)malloc(strlen(type)+1);
172 field->flag = flag;
173 field->next = NULL;
174 field->flag = 0;
175 field->minOccurs = mino;
176 field->maxOccurs = maxo;
177 field->parentObj = parentObj;
178 field->attrName = NULL;
179
180 strcpy(field->name, name);
181 strcpy(field->type, type);
182
183 return field;
184 }
185
186
187 static
fieldFree(HFIELD field)188 void fieldFree(HFIELD field)
189 {
190 if (field)
191 {
192 if (field->name) free(field->name);
193 if (field->type) free(field->type);
194 if (field->attrName) free(field->attrName);
195 if (field->next) fieldFree(field->next);
196
197 free(field);
198 }
199 }
200
201
202 static
objAddField(HCOMPLEXTYPE obj,HFIELD field)203 void objAddField(HCOMPLEXTYPE obj, HFIELD field)
204 {
205 printf("ADD FIELD %s %s\n", obj->type, field->type);
206 if (obj->tail)
207 {
208 obj->tail->next = field;
209 }
210
211 if (!obj->head)
212 {
213 obj->head = field;
214 }
215
216 obj->tail = field;
217 }
218
219
220 static
objFreeComplexType(HCOMPLEXTYPE obj)221 void objFreeComplexType(HCOMPLEXTYPE obj)
222 {
223 if (obj)
224 {
225 if (obj->type) free(obj->type);
226 if (obj->base_type) free(obj->base_type);
227 if (obj->head) fieldFree(obj->head);
228
229 free(obj);
230 }
231 }
232
233
objRegistryAddComplexType(HCOMPLEXTYPE obj)234 static void objRegistryAddComplexType(HCOMPLEXTYPE obj)
235 {
236 if (objRegistry.tail)
237 {
238 objRegistry.tail->next = obj;
239 }
240
241 if (!objRegistry.head)
242 {
243 objRegistry.head = obj;
244 }
245
246 objRegistry.tail = obj;
247 }
248
249
250
resCreate(const char * type)251 HRESTRICTION resCreate(const char *type)
252 {
253 HRESTRICTION res = (HRESTRICTION)malloc(sizeof(struct RESTRICTION));
254 res->mode = RES_MODE_EMPTY;
255 res->type = (char*)malloc(strlen(type)+1);
256 strcpy(res->type, type);
257
258 res->minInclusiveSet = 0;
259 res->maxInclusiveSet = 0;
260 res->minExclusiveSet = 0;
261 res->maxExclusiveSet = 0;
262
263 res->enumeration = Enumeration_Create();
264
265 return res;
266 }
267
268
269