00001
00020
00021
00022
00023 #include "adaptive.h"
00024 #include "emalloc.h"
00025 #include "freelist.h"
00026
00027 #ifdef __UNIX__
00028 #include <assert.h>
00029 #endif
00030 #include <stdio.h>
00031
00032
00033
00034
00046 int AddAdaptedClass(ADAPT_TEMPLATES Templates,
00047 ADAPT_CLASS Class,
00048 CLASS_ID ClassId) {
00049 INT_CLASS IntClass;
00050 CLASS_INDEX ClassIndex;
00051
00052 assert (Templates != NULL);
00053 assert (Class != NULL);
00054 assert (LegalClassId (ClassId));
00055 assert (UnusedClassIdIn (Templates->Templates, ClassId));
00056 assert (Class->NumPermConfigs == 0);
00057
00058 IntClass = NewIntClass (1, 1);
00059 ClassIndex = AddIntClass (Templates->Templates, ClassId, IntClass);
00060
00061 assert (Templates->Class[ClassIndex] == NULL);
00062
00063 Templates->Class[ClassIndex] = Class;
00064
00065 return (ClassIndex);
00066
00067 }
00068
00069
00070
00080 void FreeTempConfig(TEMP_CONFIG Config) {
00081 assert (Config != NULL);
00082
00083 destroy_nodes (Config->ContextsSeen, memfree);
00084 FreeBitVector (Config->Protos);
00085 c_free_struct (Config, sizeof (TEMP_CONFIG_STRUCT), "TEMP_CONFIG_STRUCT");
00086
00087 }
00088
00089
00093 void FreeTempProto(void *arg) {
00094 PROTO proto = (PROTO) arg;
00095
00096 c_free_struct (proto, sizeof (TEMP_PROTO_STRUCT), "TEMP_PROTO_STRUCT");
00097 }
00098
00099
00100
00111 ADAPT_CLASS NewAdaptedClass() {
00112 ADAPT_CLASS Class;
00113 int i;
00114
00115 Class = (ADAPT_CLASS) Emalloc (sizeof (ADAPT_CLASS_STRUCT));
00116 Class->NumPermConfigs = 0;
00117 Class->TempProtos = NIL;
00118
00119 Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
00120 Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
00121 zero_all_bits (Class->PermProtos, WordsInVectorOfSize (MAX_NUM_PROTOS));
00122 zero_all_bits (Class->PermConfigs, WordsInVectorOfSize (MAX_NUM_CONFIGS));
00123
00124 for (i = 0; i < MAX_NUM_CONFIGS; i++)
00125 TempConfigFor (Class, i) = NULL;
00126
00127 return (Class);
00128
00129 }
00130
00131
00132
00136 void free_adapted_class(ADAPT_CLASS adapt_class) {
00137 int i;
00138
00139 for (i = 0; i < MAX_NUM_CONFIGS; i++) {
00140 if (ConfigIsPermanent (adapt_class, i)
00141 && PermConfigFor (adapt_class, i) != NULL)
00142 Efree (PermConfigFor (adapt_class, i));
00143 else if (!ConfigIsPermanent (adapt_class, i)
00144 && TempConfigFor (adapt_class, i) != NULL)
00145 FreeTempConfig (TempConfigFor (adapt_class, i));
00146 }
00147 FreeBitVector (adapt_class->PermProtos);
00148 FreeBitVector (adapt_class->PermConfigs);
00149 destroy_nodes (adapt_class->TempProtos, FreeTempProto);
00150 Efree(adapt_class);
00151 }
00152
00153
00154
00164 ADAPT_TEMPLATES NewAdaptedTemplates() {
00165 ADAPT_TEMPLATES Templates;
00166 int i;
00167
00168 Templates = (ADAPT_TEMPLATES) Emalloc (sizeof (ADAPT_TEMPLATES_STRUCT));
00169
00170 Templates->Templates = NewIntTemplates ();
00171 Templates->NumPermClasses = 0;
00172
00173 for (i = 0; i < MAX_NUM_CLASSES; i++)
00174 Templates->Class[i] = NULL;
00175
00176 return (Templates);
00177
00178 }
00179
00180
00181
00185 void free_adapted_templates(ADAPT_TEMPLATES templates) {
00186
00187 if (templates != NULL) {
00188 int i;
00189 for (i = 0; i < NumClassesIn (templates->Templates); i++)
00190 free_adapted_class (templates->Class[i]);
00191 free_int_templates (templates->Templates);
00192 Efree(templates);
00193 }
00194 }
00195
00196
00197
00207 TEMP_CONFIG NewTempConfig(int MaxProtoId) {
00208 TEMP_CONFIG Config;
00209 int NumProtos = MaxProtoId + 1;
00210
00211 Config =
00212 (TEMP_CONFIG) c_alloc_struct (sizeof (TEMP_CONFIG_STRUCT),
00213 "TEMP_CONFIG_STRUCT");
00214 Config->Protos = NewBitVector (NumProtos);
00215
00216 Config->NumTimesSeen = 1;
00217 Config->MaxProtoId = MaxProtoId;
00218 Config->ProtoVectorSize = WordsInVectorOfSize (NumProtos);
00219 Config->ContextsSeen = NIL;
00220 zero_all_bits (Config->Protos, Config->ProtoVectorSize);
00221
00222 return (Config);
00223
00224 }
00225
00226
00227
00237 TEMP_PROTO NewTempProto() {
00238 return ((TEMP_PROTO)
00239 c_alloc_struct (sizeof (TEMP_PROTO_STRUCT), "TEMP_PROTO_STRUCT"));
00240 }
00241
00242
00243
00254 void PrintAdaptedTemplates(FILE *File, ADAPT_TEMPLATES Templates) {
00255 int i;
00256 INT_CLASS IClass;
00257 ADAPT_CLASS AClass;
00258
00259 #ifndef SECURE_NAMES
00260 fprintf (File, "\n\nSUMMARY OF ADAPTED TEMPLATES:\n\n");
00261 fprintf (File, "Num classes = %d; Num permanent classes = %d\n\n",
00262 NumClassesIn (Templates->Templates), Templates->NumPermClasses);
00263 fprintf (File, "Index Id NC NPC NP NPP\n");
00264 fprintf (File, "------------------------\n");
00265
00266 for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
00267 IClass = ClassForIndex (Templates->Templates, i);
00268 AClass = Templates->Class[i];
00269
00270 fprintf (File, "%5d %c %3d %3d %3d %3d\n",
00271 i, ClassIdForIndex (Templates->Templates, i),
00272 NumIntConfigsIn (IClass), AClass->NumPermConfigs,
00273 NumIntProtosIn (IClass),
00274 NumIntProtosIn (IClass) - count (AClass->TempProtos));
00275 }
00276 #endif
00277 fprintf (File, "\n");
00278
00279 }
00280
00281
00282
00293 ADAPT_CLASS ReadAdaptedClass(FILE *File) {
00294 int NumTempProtos;
00295 int NumConfigs;
00296 int i;
00297 ADAPT_CLASS Class;
00298 TEMP_PROTO TempProto;
00299
00300
00301 Class = (ADAPT_CLASS) Emalloc (sizeof (ADAPT_CLASS_STRUCT));
00302 fread ((char *) Class, sizeof (ADAPT_CLASS_STRUCT), 1, File);
00303
00304
00305 Class->PermProtos = NewBitVector (MAX_NUM_PROTOS);
00306 Class->PermConfigs = NewBitVector (MAX_NUM_CONFIGS);
00307 fread ((char *) Class->PermProtos, sizeof (UINT32),
00308 WordsInVectorOfSize (MAX_NUM_PROTOS), File);
00309 fread ((char *) Class->PermConfigs, sizeof (UINT32),
00310 WordsInVectorOfSize (MAX_NUM_CONFIGS), File);
00311
00312
00313 fread ((char *) &NumTempProtos, sizeof (int), 1, File);
00314 Class->TempProtos = NIL;
00315 for (i = 0; i < NumTempProtos; i++) {
00316 TempProto =
00317 (TEMP_PROTO) c_alloc_struct (sizeof (TEMP_PROTO_STRUCT),
00318 "TEMP_PROTO_STRUCT");
00319 fread ((char *) TempProto, sizeof (TEMP_PROTO_STRUCT), 1, File);
00320 Class->TempProtos = push_last (Class->TempProtos, TempProto);
00321 }
00322
00323
00324 fread ((char *) &NumConfigs, sizeof (int), 1, File);
00325 for (i = 0; i < NumConfigs; i++)
00326 if (test_bit (Class->PermConfigs, i))
00327 Class->Config[i].Perm = ReadPermConfig (File);
00328 else
00329 Class->Config[i].Temp = ReadTempConfig (File);
00330
00331 return (Class);
00332
00333 }
00334
00335
00336
00347 ADAPT_TEMPLATES ReadAdaptedTemplates(FILE *File) {
00348 int i;
00349 ADAPT_TEMPLATES Templates;
00350
00351
00352 Templates = (ADAPT_TEMPLATES) Emalloc (sizeof (ADAPT_TEMPLATES_STRUCT));
00353 fread ((char *) Templates, sizeof (ADAPT_TEMPLATES_STRUCT), 1, File);
00354
00355
00356 Templates->Templates = ReadIntTemplates (File, FALSE);
00357
00358
00359 for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
00360 Templates->Class[i] = ReadAdaptedClass (File);
00361 }
00362 return (Templates);
00363
00364 }
00365
00366
00367
00380 PERM_CONFIG ReadPermConfig(FILE *File) {
00381 PERM_CONFIG Config;
00382 UINT8 NumAmbigs;
00383
00384 fread ((char *) &NumAmbigs, sizeof (UINT8), 1, File);
00385 Config = (PERM_CONFIG) Emalloc (sizeof (char) * (NumAmbigs + 1));
00386 fread (Config, sizeof (char), NumAmbigs, File);
00387 Config[NumAmbigs] = '\0';
00388
00389 return (Config);
00390
00391 }
00392
00393
00394
00405 TEMP_CONFIG ReadTempConfig(FILE *File) {
00406 TEMP_CONFIG Config;
00407
00408 Config =
00409 (TEMP_CONFIG) c_alloc_struct (sizeof (TEMP_CONFIG_STRUCT),
00410 "TEMP_CONFIG_STRUCT");
00411 fread ((char *) Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);
00412
00413 Config->Protos = NewBitVector (Config->ProtoVectorSize * BITSINLONG);
00414 fread ((char *) Config->Protos, sizeof (UINT32),
00415 Config->ProtoVectorSize, File);
00416
00417 return (Config);
00418
00419 }
00420
00421
00422
00434 void WriteAdaptedClass(FILE *File, ADAPT_CLASS Class, int NumConfigs) {
00435 int NumTempProtos;
00436 LIST TempProtos;
00437 int i;
00438
00439
00440 fwrite ((char *) Class, sizeof (ADAPT_CLASS_STRUCT), 1, File);
00441
00442
00443 fwrite ((char *) Class->PermProtos, sizeof (UINT32),
00444 WordsInVectorOfSize (MAX_NUM_PROTOS), File);
00445 fwrite ((char *) Class->PermConfigs, sizeof (UINT32),
00446 WordsInVectorOfSize (MAX_NUM_CONFIGS), File);
00447
00448
00449 NumTempProtos = count (Class->TempProtos);
00450 fwrite ((char *) &NumTempProtos, sizeof (int), 1, File);
00451 TempProtos = Class->TempProtos;
00452 iterate (TempProtos) {
00453 void* proto = first(TempProtos);
00454 fwrite ((char *) proto, sizeof (TEMP_PROTO_STRUCT), 1, File);
00455 }
00456
00457
00458 fwrite ((char *) &NumConfigs, sizeof (int), 1, File);
00459 for (i = 0; i < NumConfigs; i++)
00460 if (test_bit (Class->PermConfigs, i))
00461 WritePermConfig (File, Class->Config[i].Perm);
00462 else
00463 WriteTempConfig (File, Class->Config[i].Temp);
00464
00465 }
00466
00467
00468
00479 void WriteAdaptedTemplates(FILE *File, ADAPT_TEMPLATES Templates) {
00480 int i;
00481
00482
00483 fwrite ((char *) Templates, sizeof (ADAPT_TEMPLATES_STRUCT), 1, File);
00484
00485
00486 WriteIntTemplates (File, Templates->Templates);
00487
00488
00489 for (i = 0; i < NumClassesIn (Templates->Templates); i++) {
00490 WriteAdaptedClass (File, Templates->Class[i],
00491 NumIntConfigsIn (ClassForIndex
00492 (Templates->Templates, i)));
00493 }
00494 }
00495
00496
00497
00508 void WritePermConfig(FILE *File, PERM_CONFIG Config) {
00509 UINT8 NumAmbigs;
00510
00511 assert (Config != NULL);
00512
00513 NumAmbigs = strlen (Config);
00514 fwrite ((char *) &NumAmbigs, sizeof (UINT8), 1, File);
00515 fwrite (Config, sizeof (char), NumAmbigs, File);
00516
00517 }
00518
00519
00520
00531 void WriteTempConfig(FILE *File, TEMP_CONFIG Config) {
00532 assert (Config != NULL);
00533
00534 assert (Config->ContextsSeen == NULL);
00535
00536 fwrite ((char *) Config, sizeof (TEMP_CONFIG_STRUCT), 1, File);
00537 fwrite ((char *) Config->Protos, sizeof (UINT32),
00538 Config->ProtoVectorSize, File);
00539
00540 }