SecuritySNACCRuntime/compiler/back-ends/c-gen/gen-print.c

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 /*
  20  * compiler/back-ends/c-gen/gen-print.c - routines for printing C hierachical print routines
  21  *
  22  * Mike Sample
  23  * 92/04
  24  * Copyright (C) 1991, 1992 Michael Sample
  25  *            and the University of British Columbia
  26  *
  27  * This program is free software; you can redistribute it and/or modify
  28  * it under the terms of the GNU General Public License as published by
  29  * the Free Software Foundation; either version 2 of the License, or
  30  * (at your option) any later version.
  31  *
  32  * $Header: /cvs/Darwin/Security/SecuritySNACCRuntime/compiler/back-ends/c-gen/gen-print.c,v 1.1.1.1 2001/05/18 23:14:09 mb Exp $
  33  * $Log: gen-print.c,v $
  34  * Revision 1.1.1.1  2001/05/18 23:14:09  mb
  35  * Move from private repository to open source repository
  36  *
  37  * Revision 1.2  2001/05/05 00:59:28  rmurphy
  38  * Adding darwin license headers
  39  *
  40  * Revision 1.1.1.1  1999/03/16 18:06:42  aram
  41  * Originals from SMIME Free Library.
  42  *
  43  * Revision 1.3  1995/07/25 18:43:18  rj
  44  * file name has been shortened for redundant part: c-gen/gen-c-print -> c-gen/gen-print.
  45  *
  46  * changed `_' to `-' in file names.
  47  *
  48  * Revision 1.2  1994/09/01  00:23:43  rj
  49  * snacc_config.h and other superfluous .h files removed.
  50  *
  51  * Revision 1.1  1994/08/28  09:48:28  rj
  52  * first check-in. for a list of changes to the snacc-1.1 distribution please refer to the ChangeLog.
  53  *
  54  */
  55
  56 #include <stdio.h>
  57
  58 #include "asn-incl.h"
  59 #include "asn1module.h"
  60 #include "mem.h"
  61 #include "define.h"
  62 #include "rules.h"
  63 #include "type-info.h"
  64 #include "str-util.h"
  65 #include "util.h"
  66 #include "gen-print.h"
  67
  68 static char *returnTypeG = "void";
  69 static char *valueArgNameG = "v";
  70 static char *fileTypeNameG = "FILE*";
  71 static char *indentTypeNameG = "unsigned short int";
  72 static CRules *genPrintCRulesG;
  73 /* non-exported prototypes */
  74
  75 static void PrintCPrintPrototype PROTO ((FILE *hdr, TypeDef *td));
  76 static void PrintCPrintDeclaration PROTO ((FILE *src, TypeDef *td));
  77 static void PrintCPrintDefine PROTO ((FILE *hdr, TypeDef *td));
  78 static void PrintCPrintLocals PROTO ((FILE *src,TypeDef *td));
  79 /*
  80 static void PrintCPrintElmts PROTO ((FILE *src, TypeDef *td, Type *parent, NamedTypeList *elmts, char *varName));
  81 */
  82 static void PrintCChoiceElmtPrint PROTO ((FILE *src, TypeDef *td, Type *parent, NamedTypeList *elmts, NamedType *e, char *varName));
  83
  84
  85 static void PrintCElmtPrintWithIndent PROTO ((FILE *src, TypeDef *td, Type *parent, NamedTypeList *elmts, NamedType *e, char *varName, int allOpt));
  86
  87 static void PrintCChoicePrintRoutine PROTO ((FILE *src, FILE *hdr, CRules *r, ModuleList *mods, Module *m, TypeDef *td));
  88
  89 static void PrintCSetPrintRoutine  PROTO ((FILE *src, FILE *hdr, CRules *r, ModuleList *mods, Module *m, TypeDef *td));
  90 static void PrintCSeqPrintRoutine  PROTO ((FILE *src, FILE *hdr, CRules *r, ModuleList *mods, Module *m, TypeDef *td));
  91 static void PrintCSeqOfPrintRoutine PROTO ((FILE *src, FILE *hdr, CRules *r, ModuleList *mods, Module *m, TypeDef *td));
  92 static void PrintCSetOfPrintRoutine PROTO ((FILE *src, FILE *hdr, CRules *r, ModuleList *mods, Module *m, TypeDef *td));
  93
  94
  95
  96 void
  97 PrintCPrinter PARAMS ((src, hdr, r, mods, m, td),
  98     FILE *src _AND_
  99     FILE *hdr _AND_
 100     CRules *r _AND_
 101     ModuleList *mods _AND_
 102     Module *m _AND_
 103     TypeDef *td)
 104 {
 105     if ((td->cTypeDefInfo == NULL) || !(td->cTypeDefInfo->genPrintRoutine))
 106         return;
 107
 108     genPrintCRulesG = r;
 109     switch (td->type->basicType->choiceId)
 110     {
 111         case BASICTYPE_IMPORTTYPEREF:  /* type references */
 112         case BASICTYPE_LOCALTYPEREF:
 113         case BASICTYPE_BOOLEAN:  /* library type */
 114         case BASICTYPE_REAL:  /* library type */
 115         case BASICTYPE_OCTETSTRING:  /* library type */
 116         case BASICTYPE_NULL:  /* library type */
 117         case BASICTYPE_OID:  /* library type */
 118         case BASICTYPE_INTEGER:  /* library type */
 119         case BASICTYPE_BITSTRING:  /* library type */
 120         case BASICTYPE_ENUMERATED:  /* library type */
 121         case BASICTYPE_ANYDEFINEDBY:  /* ANY types */
 122         case BASICTYPE_ANY:
 123             PrintCPrintDefine (hdr, td);
 124             fprintf (hdr, "\n\n");
 125             break;
 126
 127         case BASICTYPE_SETOF:
 128             PrintCSetOfPrintRoutine (src, hdr, r, mods, m, td);
 129             break;
 130
 131         case BASICTYPE_SEQUENCEOF:
 132             PrintCSeqOfPrintRoutine (src, hdr, r, mods, m, td);
 133             break;
 134
 135         case BASICTYPE_CHOICE:
 136             PrintCChoicePrintRoutine (src, hdr, r, mods, m, td);
 137             break;
 138
 139         case BASICTYPE_SET:
 140             PrintCSetPrintRoutine (src, hdr, r, mods, m, td);
 141             break;
 142
 143
 144         case BASICTYPE_SEQUENCE:
 145             PrintCSeqPrintRoutine (src, hdr, r, mods, m, td);
 146             break;
 147
 148         default:
 149             break;
 150     }
 151 }  /*  PrintCPrint */
 152
 153
 154 /*
 155  * Prints prototype for encode routine in hdr file
 156  */
 157 static void
 158 PrintCPrintPrototype PARAMS ((hdr, td),
 159     FILE *hdr _AND_
 160     TypeDef *td)
 161 {
 162     CTDI *ctdi;
 163
 164     ctdi = td->cTypeDefInfo;
 165     fprintf (hdr,"%s %s PROTO ((%s f, %s *v, %s indent));\n", returnTypeG, ctdi->printRoutineName, fileTypeNameG, ctdi->cTypeName, indentTypeNameG);
 166
 167 }  /*  PrintCPrintPrototype */
 168
 169
 170
 171 /*
 172  * Prints declarations of encode routine for the given type def
 173  */
 174 static void
 175 PrintCPrintDeclaration PARAMS ((src, td),
 176     FILE *src _AND_
 177     TypeDef *td)
 178 {
 179     CTDI *ctdi;
 180
 181     ctdi =  td->cTypeDefInfo;
 182     fprintf (src,"%s\n%s PARAMS ((f, v, indent),\n%s f _AND_\n%s *v _AND_\n%s indent)\n", returnTypeG, ctdi->printRoutineName, fileTypeNameG, ctdi->cTypeName, indentTypeNameG);
 183
 184 }  /*  PrintCPrintDeclaration */
 185
 186
 187
 188
 189 static void
 190 PrintCPrintDefine PARAMS ((hdr, td),
 191     FILE *hdr _AND_
 192     TypeDef *td)
 193 {
 194     fprintf(hdr, "#define %s %s", td->cTypeDefInfo->printRoutineName, td->type->cTypeRefInfo->printRoutineName);
 195 /*
 196     fprintf(hdr, "#define %s(f, v, indent)  ", td->cTypeDefInfo->printRoutineName);
 197     fprintf (hdr, "%s (f, v, indent)", td->type->cTypeRefInfo->printRoutineName);
 198 */
 199 }  /*  PrintCPrintDefine */
 200
 201
 202
 203
 204 static void
 205 PrintCPrintLocals PARAMS ((src, td),
 206     FILE *src _AND_
 207     TypeDef *td)
 208 {
 209     /* none yet */
 210 }  /*  PrintCPrintLocals */
 211
 212
 213 /*
 214 static void
 215 PrintCPrintElmts PARAMS ((src, td, parent, elmts, varName),
 216     FILE *src _AND_
 217     TypeDef *td _AND_
 218     Type *parent _AND_
 219     NamedTypeList *elmts _AND_
 220     char *varName)
 221 {
 222     NamedType *e;
 223
 224
 225     FOR_EACH_LIST_ELMT (e, elmts)
 226         PrintCElmtPrint (src, td, parent, elmts, e, varName);
 227 }  PrintCBerElmtsEncodeCode */
 228
 229
 230
 231 /*
 232  * Prints code for printing a CHOICE element
 233  *
 234  */
 235 static void
 236 PrintCChoiceElmtPrint PARAMS ((src, td, parent, elmts,  e, varName),
 237     FILE *src _AND_
 238     TypeDef *td _AND_
 239     Type *parent _AND_
 240     NamedTypeList *elmts _AND_
 241     NamedType *e _AND_
 242     char *varName)
 243 {
 244     CTRI *ctri;
 245     char elmtVarRef[MAX_VAR_REF];
 246     Type *tmpType;
 247     int inTailOpts;
 248
 249     ctri =  e->type->cTypeRefInfo;
 250
 251
 252     /* build ref to the elmt */
 253     MakeVarPtrRef (genPrintCRulesG, td, parent, e->type, varName, elmtVarRef);
 254
 255     if (e->fieldName != NULL)
 256     {
 257         fprintf (src,"    fprintf (f,\"%s \");\n", e->fieldName);
 258         fprintf (src,"    %s (f, %s, indent + stdIndentG);\n", e->type->cTypeRefInfo->printRoutineName, elmtVarRef);
 259     }
 260     else
 261     {
 262         fprintf (src,"    %s (f, %s, indent + stdIndentG);\n", e->type->cTypeRefInfo->printRoutineName, elmtVarRef);
 263     }
 264
 265 }  /*  PrintCChoiceElmtPrint */
 266
 267 /*
 268  * Prints code for printing an elmt of a SEQ or SET
 269  *
 270  * Does funny things to print commas correctly
 271  * eg for the following type
 272  * Foo ::= SET
 273  * {
 274  *      A,                   --> print   A ",\n"
 275  *      B,                               B ",\n"
 276  *      C OPTIONAL,                      C ",\n" if C present
 277  *      D,                               D ",\n"
 278  *      E,                               E ",\n"
 279  *      F,                               F       <- nothing after last non-opt
 280  *                                                  before tail opts.
 281  *      G OPTIONAL,                      ",\n" G
 282  *      H OPTIONAL                       ",\n" H "\n"
 283  * }
 284
 285  */
 286 static void
 287 PrintCElmtPrintWithIndent PARAMS ((src, td, parent, elmts, e, varName, allOpt),
 288     FILE *src _AND_
 289     TypeDef *td _AND_
 290     Type *parent _AND_
 291     NamedTypeList *elmts _AND_
 292     NamedType *e _AND_
 293     char *varName _AND_
 294     int allOpt)
 295 {
 296     CTRI *ctri;
 297     char elmtVarRef[MAX_VAR_REF];
 298     Type *tmpType;
 299     int inTailOpts;
 300
 301     ctri =  e->type->cTypeRefInfo;
 302
 303     /* this assumes the elmts->curr == e */
 304     inTailOpts = IsTailOptional (elmts);
 305
 306     /* build ref to the elmt */
 307     MakeVarPtrRef (genPrintCRulesG, td, parent, e->type, varName, elmtVarRef);
 308
 309     /* if optional then put in NULL check */
 310     if (e->type->optional || (e->type->defaultVal != NULL))
 311         fprintf (src, "    if (%s (%s))\n    {\n", ctri->optTestRoutineName, elmtVarRef);
 312
 313     if (allOpt)
 314     {
 315         if (e != FIRST_LIST_ELMT (elmts))
 316         {
 317             fprintf (src, "    if (!nonePrinted)\n");
 318             fprintf (src, "        fprintf (f,\",\\n\");\n");
 319         }
 320         fprintf (src, "    nonePrinted = FALSE;\n");
 321     }
 322     else if ((inTailOpts) && (e != FIRST_LIST_ELMT (elmts)))
 323         fprintf (src, "    fprintf (f,\",\\n\");\n");
 324
 325     fprintf (src,"    Indent (f, indent + stdIndentG);\n");
 326
 327     if (e->fieldName != NULL)
 328         fprintf (src,"    fprintf (f,\"%s \");\n", e->fieldName);
 329
 330     fprintf (src,"    %s (f, %s, indent + stdIndentG);\n", e->type->cTypeRefInfo->printRoutineName, elmtVarRef);
 331
 332     if ((e != LAST_LIST_ELMT (elmts)) &&
 333          (!inTailOpts) &&
 334          (!NextIsTailOptional (elmts)))
 335         fprintf (src,"    fprintf (f, \",\\n\");\n");
 336
 337
 338     /* write closing brkt for NULL check for optional elmts */
 339     if (e->type->optional || (e->type->defaultVal != NULL))
 340         fprintf (src, "    }\n");
 341
 342     if (e == LAST_LIST_ELMT (elmts))
 343         fprintf (src,"    fprintf (f,\"\\n\");\n");
 344
 345 }  /*  PrintCElmtPrintWithIndent */
 346
 347
 348 static void
 349 PrintCChoicePrintRoutine PARAMS ((src, hdr, r, mods, m, td),
 350     FILE *src _AND_
 351     FILE *hdr _AND_
 352     CRules *r _AND_
 353     ModuleList *mods _AND_
 354     Module *m _AND_
 355     TypeDef *td)
 356 {
 357     NamedType *e;
 358
 359     PrintCPrintPrototype (hdr,td);
 360
 361     PrintCPrintDeclaration (src, td);
 362     fprintf (src,"{\n");
 363     PrintCPrintLocals (src,td);
 364     fprintf (src,"    switch (%s->%s)\n", valueArgNameG, td->type->cTypeRefInfo->choiceIdEnumFieldName);
 365     fprintf (src,"    {\n");
 366
 367     FOR_EACH_LIST_ELMT (e, td->type->basicType->a.choice)
 368     {
 369         fprintf (src,"      case %s:\n",e->type->cTypeRefInfo->choiceIdSymbol);
 370         fprintf (src,"      ");
 371         PrintCChoiceElmtPrint (src, td, td->type, td->type->basicType->a.choice, e, valueArgNameG);
 372         fprintf (src,"          break;\n\n");
 373     }
 374     fprintf (src,"    }\n");
 375 /*    fprintf (src,"    fprintf (f,\"\\n\");\n"); */
 376
 377     fprintf (src,"}  /* %s */\n\n", td->cTypeDefInfo->printRoutineName);
 378
 379 } /* PrintCChoicePrintRoutine */
 380
 381
 382
 383 static void
 384 PrintCSetPrintRoutine PARAMS ((src, hdr, r, mods, m, td),
 385     FILE *src _AND_
 386     FILE *hdr _AND_
 387     CRules *r _AND_
 388     ModuleList *mods _AND_
 389     Module *m _AND_
 390     TypeDef *td)
 391 {
 392     NamedType *e;
 393     int allOpt;
 394
 395     PrintCPrintPrototype (hdr,td);
 396
 397     PrintCPrintDeclaration (src, td);
 398     fprintf (src,"{\n");
 399     PrintCPrintLocals (src,td);
 400
 401     allOpt = AllElmtsOptional (td->type->basicType->a.set);
 402     /*
 403      * print extra local variable so commas are handled correctly
 404      * when all elements are optional
 405      */
 406     if (allOpt)
 407         fprintf (src,"    int nonePrinted = TRUE;\n\n");
 408
 409     fprintf (src,"    if (%s == NULL)\n", valueArgNameG);
 410     fprintf (src,"        return;\n\n");
 411
 412     fprintf (src,"    fprintf (f,\"{ -- SET --\\n\");\n\n");
 413
 414
 415     FOR_EACH_LIST_ELMT (e, td->type->basicType->a.set)
 416     {
 417         PrintCElmtPrintWithIndent (src, td, td->type, td->type->basicType->a.set, e, valueArgNameG, allOpt);
 418     }
 419     fprintf (src,"    Indent (f, indent);\n");
 420     fprintf (src,"    fprintf (f,\"}\");\n");
 421
 422     fprintf (src,"}  /* %s */\n\n", td->cTypeDefInfo->printRoutineName);
 423
 424 } /* PrintCSetPrintRoutine */
 425
 426
 427
 428 static void
 429 PrintCSeqPrintRoutine PARAMS ((src, hdr, r, mods, m, td),
 430     FILE *src _AND_
 431     FILE *hdr _AND_
 432     CRules *r _AND_
 433     ModuleList *mods _AND_
 434     Module *m _AND_
 435     TypeDef *td)
 436 {
 437     NamedType *e;
 438     int allOpt;
 439
 440     PrintCPrintPrototype (hdr,td);
 441
 442     PrintCPrintDeclaration (src, td);
 443     fprintf (src,"{\n");
 444     PrintCPrintLocals (src,td);
 445
 446     allOpt = AllElmtsOptional (td->type->basicType->a.set);
 447     /*
 448      * print extra local variable so commas are handled correctly
 449      * when all elements are optional
 450      */
 451     if (allOpt)
 452         fprintf (src,"    int nonePrinted = TRUE;\n\n");
 453
 454     fprintf (src,"    if (%s == NULL)\n", valueArgNameG);
 455     fprintf (src,"        return;\n\n");
 456
 457     fprintf (src,"    fprintf (f,\"{ -- SEQUENCE --\\n\");\n\n");
 458
 459     FOR_EACH_LIST_ELMT (e, td->type->basicType->a.sequence)
 460     {
 461         PrintCElmtPrintWithIndent (src, td, td->type, td->type->basicType->a.sequence, e, valueArgNameG, allOpt);
 462     }
 463     fprintf (src,"    Indent (f, indent);\n");
 464     fprintf (src,"    fprintf (f,\"}\");\n");
 465
 466     fprintf (src,"}  /* %s */\n\n", td->cTypeDefInfo->printRoutineName);
 467 } /* PrintCSeqPrintRoutine */
 468
 469
 470
 471 static void
 472 PrintCSetOfPrintRoutine PARAMS ((src, hdr, r, mods, m, td),
 473     FILE *src _AND_
 474     FILE *hdr _AND_
 475     CRules *r _AND_
 476     ModuleList *mods _AND_
 477     Module *m _AND_
 478     TypeDef *td)
 479 {
 480     NamedType *e;
 481
 482     PrintCPrintPrototype (hdr,td);
 483
 484     PrintCPrintDeclaration (src, td);
 485     fprintf (src,"{\n");
 486     PrintCPrintLocals (src,td);
 487
 488     fprintf (src,"    %s *tmp;\n", td->type->basicType->a.setOf->cTypeRefInfo->cTypeName);
 489
 490     fprintf (src,"    if (%s == NULL)\n", valueArgNameG);
 491     fprintf (src,"        return;\n");
 492
 493     fprintf (src,"    fprintf (f,\"{ -- SET OF -- \\n\");\n");
 494
 495     fprintf (src,"    FOR_EACH_LIST_ELMT (tmp, %s)\n", valueArgNameG);
 496     fprintf (src,"    {\n");
 497     fprintf (src,"        Indent (f, indent+ stdIndentG);\n");
 498     fprintf (src,"        %s (f, tmp, indent + stdIndentG);\n", td->type->basicType->a.setOf->cTypeRefInfo->printRoutineName);
 499     fprintf (src,"        if (tmp != (%s*)LAST_LIST_ELMT (%s))\n", td->type->basicType->a.setOf->cTypeRefInfo->cTypeName, valueArgNameG);
 500     fprintf (src,"            fprintf (f,\",\\n\");\n");
 501     fprintf (src,"    }\n");
 502     fprintf (src,"    fprintf (f,\"\\n\");\n");
 503     fprintf (src,"    Indent (f, indent);\n");
 504     fprintf (src,"    fprintf (f,\"}\");\n");
 505
 506     fprintf (src,"}  /* %s */\n\n", td->cTypeDefInfo->printRoutineName);
 507
 508 } /* PrintCSetOfPrintRoutine */
 509
 510 static void
 511 PrintCSeqOfPrintRoutine PARAMS ((src, hdr, r, mods, m, td),
 512     FILE *src _AND_
 513     FILE *hdr _AND_
 514     CRules *r _AND_
 515     ModuleList *mods _AND_
 516     Module *m _AND_
 517     TypeDef *td)
 518 {
 519     NamedType *e;
 520
 521     PrintCPrintPrototype (hdr,td);
 522
 523     PrintCPrintDeclaration (src, td);
 524     fprintf (src,"{\n");
 525     PrintCPrintLocals (src,td);
 526
 527     fprintf (src,"    %s *tmp;\n", td->type->basicType->a.setOf->cTypeRefInfo->cTypeName);
 528
 529     fprintf (src,"    if (%s == NULL)\n", valueArgNameG);
 530     fprintf (src,"        return;\n");
 531
 532     fprintf (src,"    fprintf (f,\"{ -- SEQUENCE OF -- \\n\");\n");
 533
 534     fprintf (src,"    FOR_EACH_LIST_ELMT (tmp, %s)\n", valueArgNameG);
 535     fprintf (src,"    {\n");
 536     fprintf (src,"        Indent (f, indent+ stdIndentG);\n");
 537     fprintf (src,"        %s (f, tmp, indent + stdIndentG);\n", td->type->basicType->a.setOf->cTypeRefInfo->printRoutineName);
 538     fprintf (src,"        if (tmp != (%s*)LAST_LIST_ELMT (%s))\n", td->type->basicType->a.setOf->cTypeRefInfo->cTypeName, valueArgNameG);
 539     fprintf (src,"            fprintf (f,\",\\n\");\n");
 540     fprintf (src,"    }\n");
 541     fprintf (src,"    fprintf (f,\"\\n\");\n");
 542     fprintf (src,"    Indent (f, indent);\n");
 543     fprintf (src,"    fprintf (f,\"}\");\n");
 544
 545     fprintf (src,"}  /* %s */\n\n", td->cTypeDefInfo->printRoutineName);
 546
 547 } /* PrintCSeqOfPrintRoutine */