src/lh.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2003 University of Virginia,
   4 **         Massachusetts Institute of Technology
   5 **
   6 ** This program is free software; you can redistribute it and/or modify it
   7 ** under the terms of the GNU General Public License as published by the
   8 ** Free Software Foundation; either version 2 of the License, or (at your
   9 ** option) any later version.
  10 **
  11 ** This program is distributed in the hope that it will be useful, but
  12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 ** General Public License for more details.
  15 **
  16 ** The GNU General Public License is available from http://www.gnu.org/ or
  17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 ** MA 02111-1307, USA.
  19 **
  20 ** For information on splint: info@splint.org
  21 ** To report a bug: splint-bug@splint.org
  22 ** For more information: http://www.splint.org
  23 */
  24 /*
  25 ** lh.c
  26 **
  27 **  MODULE DESCRIPTION:
  28 **
  29 **      This module contains the I/O routines for writing out the .lh file
  30 **      generated from the .lcl file.
  31 **
  32 **  AUTHORS:
  33 **
  34 **      Gary Feldman, Technical Languages and Environments, DECspec project
  35 **      Yang Meng Tan, MIT.
  36 **
  37 **  CREATION DATE:  9 April 91
  38 **
  39 **      The lh.c module controls formatting policy.
  40 */
  41
  42 # include "splintMacros.nf"
  43 # include "basic.h"
  44 # include "osd.h"
  45 # include "lh.h"
  46
  47
  48 /*:private:*/ typedef struct
  49 {
  50   /*@open@*/ /*@dependent@*/ /*@null@*/ /*@reldef@*/ FILE *f;
  51   /*@reldef@*/ cstring name;
  52 } outFile;
  53
  54 static bool genLh;
  55 static outFile LhFile;
  56
  57 /*
  58 **
  59 **  FORWARD FUNCTIONS
  60 **
  61 */
  62
  63 /* static int colpos (int startcol, cstring line); */
  64
  65 static cstring lhTypeSpecNode (lclTypeSpecNode p_typespec);
  66 static /*@only@*/ cstring lhTypeExpr (/*@null@*/ typeExpr p_x);
  67 static /*@only@*/ cstring lhDeclaratorNode (declaratorNode p_x);
  68
  69 /*@only@*/ cstring
  70 lhFunction (lclTypeSpecNode lclTypeSpec, declaratorNode declarator)
  71 {
  72   cstring s;
  73
  74   if (!genLh)
  75     return cstring_undefined;
  76
  77   s = message ("extern %q %q;", lhTypeSpecNode (lclTypeSpec),
  78                lhDeclaratorNode (declarator));
  79
  80   return s;
  81 }
  82
  83 static /*@only@*/ cstring
  84 lhDeclaratorNode (declaratorNode x)
  85 {
  86   return (lhTypeExpr (x->type));
  87 }
  88
  89 static /*@only@*/ cstring lhTypeExpr (/*@null@*/ typeExpr x)
  90 {
  91   cstring s = cstring_undefined; /* print out types in order of appearance in source */
  92   paramNodeList params;
  93   int i;
  94
  95   if (x != (typeExpr) 0)
  96     {
  97       cstring front = cstring_undefined;
  98       cstring back  = cstring_undefined;
  99
 100       for (i = x->wrapped; i >= 1; i--)
 101         {
 102           front = cstring_appendChar (front, '(');
 103           back  = cstring_appendChar (back, ')');
 104         }
 105
 106       switch (x->kind)
 107         {
 108         case TEXPR_BASE:
 109           s = message ("%q%s", s, ltoken_getRawString (x->content.base));
 110           break;
 111         case TEXPR_PTR:
 112           s = message ("%q*%q", s, lhTypeExpr (x->content.pointer));
 113           break;
 114         case TEXPR_ARRAY:
 115           s = message ("%q%q[%q]", s,
 116                        lhTypeExpr (x->content.array.elementtype),
 117                        termNode_unparse (x->content.array.size));
 118           break;
 119         case TEXPR_FCN:
 120           s = message ("%q%q (", s, lhTypeExpr (x->content.function.returntype));
 121           params = x->content.function.args;
 122
 123           if (!paramNodeList_empty (params))
 124             {
 125               s = message ("%q%q", s,
 126                            paramNodeList_unparseComments (x->content.function.args));
 127             }
 128
 129           s = message ("%q)", s);
 130           break;
 131         }
 132       s = message ("%q%q%q", front, s, back);
 133     }
 134   else
 135     {
 136       s = cstring_makeLiteral ("?");
 137     }
 138
 139   return s;
 140 }
 141
 142 extern void
 143 lhForwardStruct (ltoken t)
 144 {
 145   if (!genLh)
 146     return;
 147
 148   lhOutLine (message ("struct %s;", ltoken_unparse (t)));
 149 }
 150
 151
 152 extern void
 153 lhForwardUnion (ltoken t)
 154 {
 155   if (!genLh)
 156     return;
 157
 158   lhOutLine (message ("union %s;", ltoken_unparse (t)));
 159 }
 160
 161 extern /*@only@*/ cstring
 162 lhType (typeNode t)
 163 {
 164   if (!genLh)
 165     return cstring_undefined;
 166
 167   if (t->kind == TK_EXPOSED)
 168     {
 169       exposedNode n = t->content.exposed;
 170
 171       if (n != (exposedNode) 0)
 172         {
 173           if (declaratorInvNodeList_size (n->decls) == 0)
 174             {
 175               /*
 176               ** Forward struct or union declaration
 177               */
 178
 179               return (cstring_appendChar (lhTypeSpecNode (n->type), ';'));
 180             }
 181           else
 182             {
 183               cstring s = cstring_undefined;
 184
 185               declaratorInvNodeList_elements (n->decls, d)
 186                 {
 187                   cstring name = declaratorNode_unparse (d->declarator);
 188                   cstring pname = declaratorNode_unparseCode (d->declarator);
 189
 190                   s = message ("%q\n# ifndef EXPOSED_TYPE_%q\ntypedef %q %q;\n# endif\n",
 191                                s, pname, lhTypeSpecNode (n->type), name);
 192                 } end_declaratorInvNodeList_elements;
 193
 194               return s;
 195             }
 196         }
 197     }
 198
 199   return cstring_undefined;
 200 }
 201
 202 static /*@only@*/ cstring
 203 lhTypeSpecNode (lclTypeSpecNode typespec)
 204 {
 205   if (!genLh)
 206     {
 207       return cstring_undefined;
 208     }
 209
 210   return (lclTypeSpecNode_unparseComments (typespec));
 211 }
 212
 213 /*@only@*/ cstring
 214 lhVarDecl (lclTypeSpecNode lclTypeSpec, initDeclNodeList initDecls,
 215            qualifierKind qualifier)
 216 {
 217   bool first = TRUE;
 218   cstring s;
 219
 220   if (!genLh)
 221     return cstring_undefined;
 222
 223   s = cstring_makeLiteral ("extern");
 224
 225   switch (qualifier)
 226     {
 227     case QLF_NONE:
 228       break;
 229     case QLF_CONST:
 230       s = message ("%q const", s);
 231       break;
 232     case QLF_VOLATILE:
 233       s = message ("%q volatile", s);
 234       break;
 235     default:                    /* ignore it */
 236       break;
 237     }
 238
 239   s = message ("%q %q ", s, lhTypeSpecNode (lclTypeSpec));
 240
 241   initDeclNodeList_elements (initDecls, i)
 242   {
 243     if (first)
 244       {
 245         s = message ("%q %q", s, declaratorNode_unparse (i->declarator));
 246         first = FALSE;
 247       }
 248     else
 249       {
 250         s = message ("%q, %q", s, declaratorNode_unparse (i->declarator));
 251       }
 252   } end_initDeclNodeList_elements;
 253
 254   return (message ("%q;", s));
 255 }
 256
 257 extern void
 258 lhCleanup (void)
 259    /*@modifies fileSystem@*/
 260 {
 261   if (!genLh)
 262     {
 263       return;
 264     }
 265   else
 266     {
 267       llassert (LhFile.f != NULL);
 268
 269       if (LhFile.f == NULL)
 270         {
 271           lldiagmsg (message ("Cannot open lh file for output: %s", LhFile.name));
 272         }
 273       else
 274         {
 275           check (fprintf (LhFile.f, "/* Output from %s */\n", LCL_PARSE_VERSION) > 0);
 276           check (fileTable_closeFile (context_fileTable (), LhFile.f));
 277           LhFile.f = NULL;
 278         }
 279     }
 280 }
 281
 282 static cstring
 283 LSLRootName (cstring filespec)
 284 {
 285   /*@access cstring@*/
 286   char *result, *startName, *tail;
 287   size_t nameLength;
 288
 289   llassert (cstring_isDefined (filespec));
 290   tail = strrchr (filespec, CONNECTCHAR);
 291   startName = (tail == NULL ? filespec : &tail[1]);
 292   tail = strrchr (startName, '.');
 293   nameLength = (tail == NULL ? strlen (startName)
 294                 : size_fromInt (tail - startName));
 295   result = dmalloc (nameLength + 1);
 296   strncpy (result, startName, nameLength);
 297   result[(int) nameLength] = '\0';
 298   return result;
 299   /*@noaccess cstring@*/
 300 }
 301
 302 void lhInit (inputStream f) /*@globals undef LhFile; @*/
 303 {
 304   static bool lherror = FALSE;
 305
 306   genLh = context_msgLh ();
 307
 308   if (!genLh)
 309     {
 310       return;
 311     }
 312
 313   LhFile.name = cstring_concatFree1 (LSLRootName (inputStream_fileName (f)),
 314                                      LH_EXTENSION);
 315   LhFile.f = fileTable_openWriteUpdateFile (context_fileTable (), LhFile.name);
 316
 317   if (LhFile.f == NULL)
 318     {
 319       genLh = FALSE;
 320       if (!lherror)
 321         {
 322           lclplainerror (message ("Cannot write temporary file: %s",
 323                                   LhFile.name));
 324           lherror = TRUE;
 325         }
 326     }
 327 }
 328
 329 void lhOutLine (/*@only@*/ cstring s)
 330 {
 331   if (genLh)
 332     {
 333       llassert (LhFile.f != NULL);
 334       DPRINTF (("lhOutLine: %s / %s", s, LhFile.name));
 335
 336       if (cstring_length (s) > 0)
 337         {
 338           check (fputs (cstring_toCharsSafe (s), LhFile.f) != EOF);
 339         }
 340
 341       check (fputc ('\n', LhFile.f) == (int) '\n');
 342     }
 343
 344   cstring_free (s);
 345 }
 346
 347 void lhExternals (interfaceNodeList x)
 348 {
 349   if (genLh)
 350     {
 351       llassert (LhFile.f != NULL);
 352
 353       /*
 354       ** Need to make sure all standard library includes come first.
 355       */
 356
 357       interfaceNodeList_elements (x, el)
 358         {
 359           if (el->kind == INF_IMPORTS)
 360             {
 361               importNodeList imps = el->content.imports;
 362
 363               importNodeList_elements (imps, il)
 364                 {
 365                   if (il->kind == IMPBRACKET)
 366                     {
 367                       lhOutLine (message ("# include <%s.h>",
 368                                           ltoken_getRawString (il->val)));
 369                     }
 370                 } end_importNodeList_elements ;
 371             }
 372         } end_interfaceNodeList_elements;
 373
 374       lhOutLine (cstring_makeLiteral ("# include \"bool.h\""));
 375
 376       interfaceNodeList_elements (x, el)
 377         {
 378           if (el->kind == INF_IMPORTS)
 379             {
 380               importNodeList imps = el->content.imports;
 381
 382               importNodeList_elements (imps, il)
 383                 {
 384                   if (il->kind != IMPBRACKET)
 385                     {
 386                       lhOutLine (message ("# include \"%s.h\"",
 387                                           ltoken_getRawString (il->val)));
 388                     }
 389                 } end_importNodeList_elements ;
 390             }
 391         } end_interfaceNodeList_elements;
 392
 393       lhOutLine (cstring_undefined);
 394     }
 395 }
 396
 397
 398