bgui/MakeProtoANSI.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * makeproto.c
   6  *
   7  * (C) Copyright 1998 Manuel Lemos.
   8  * (C) Copyright 1996-1997 Ian J. Einman.
   9  * (C) Copyright 1993-1996 Jaba Development.
  10  * (C) Copyright 1993-1996 Jan van den Baard.
  11  * All Rights Reserved.
  12  *
  13  * $Log$
  14  * Revision 1.1  2000/05/28 21:46:40  stegerg
  15  * *** empty log message ***
  16  *
  17  * Revision 42.0  2000/05/09 22:08:04  mlemos
  18  * Bumped to revision 42.0 before handing BGUI to AROS team
  19  *
  20  * Revision 41.11  2000/05/09 19:53:37  mlemos
  21  * Merged with the branch Manuel_Lemos_fixes.
  22  *
  23  * Revision 41.10.2.1  1998/10/01 23:04:17  mlemos
  24  * Fixed problems with dangling pointers to missing command line arguments.
  25  *
  26  * Revision 41.10  1998/02/25 21:11:24  mlemos
  27  * Bumping to 41.10
  28  *
  29  * Revision 1.1  1998/02/25 17:07:10  mlemos
  30  * Ian sources
  31  *
  32  *
  33  */
  34
  35 /*
  36  * Source is provided for demonstration and learning purposes only;
  37  * derivative products are a violation of international copyright.
  38  */
  39
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43
  44 typedef short BOOL;
  45 #define TRUE  1
  46 #define FALSE 0
  47
  48 /*
  49  * MakeProtoANSI HEADER SOURCE1 [SOURCE2] [SOURCE3] [...]
  50  *
  51  * HEADER: The destination file to create, containing the prototype information.
  52  *         Include this file in all of your programs that need the global functions,
  53  *         the best place would be the main header file for your project.
  54  *
  55  * SOURCE: The file(s) to create prototype information for.  These files will be
  56  *         scanned for the "makeproto" keyword, which is case-sensitive, and will
  57  *         be defined to do nothing in the final compilation (this is done in the
  58  *         generated header file).
  59  *
  60  *         Unlike some other similar proto-building utilities, this one can handle
  61  *         split lines, to make large function declarations easier.  Also, there is
  62  *         no need to change the prototype in more than one place, you can use the
  63  *         "makeproto" keyword right in the definition.
  64  */
  65
  66 void killcomments(char *buffer)
  67 {
  68    char *dest = buffer, c;
  69
  70    int c_comment = 0, cpp_comment = 0;
  71
  72    while (c = *buffer++)
  73    {
  74       switch (c)
  75       {
  76       case '/':
  77          switch (*buffer)
  78          {
  79          case '/':
  80             buffer++;
  81             cpp_comment++;
  82             break;
  83          case '*':
  84             buffer++;
  85             c_comment++;
  86             break;
  87          };
  88       case '*':
  89          if ((*buffer == '/') && (c_comment > 0))
  90          {
  91             buffer++;
  92             c_comment--;
  93             *dest++ = ' ';
  94          };
  95          break;
  96       case 10:
  97       case 13:
  98          cpp_comment = 0;
  99          break;
 100       };
 101       if (!(c_comment || cpp_comment)) *dest++ = c;
 102    };
 103    *dest = 0;
 104 }
 105
 106 void makeproto(FILE *hf, char *buffer)
 107 {
 108    BOOL protomade = FALSE, function;
 109    char c;
 110    char *brace, *equals, *semi, *start, *end, *comma;
 111
 112    killcomments(buffer);
 113
 114    while (buffer = strstr(buffer + 1, "makeproto"))
 115    {
 116       if ((buffer[-1] == ';') || (buffer[-1] == '*')) buffer[-1] = ' ';
 117
 118       if (isspace(buffer[-1]) && isspace(buffer[9]))
 119       {
 120          start  = stpblk(buffer + 9);
 121          brace  = strchr(start, '{');
 122          equals = strchr(start, '=');
 123          semi   = strchr(start, ';');
 124
 125          function = brace && (!semi || (brace < semi)) && (!equals || (brace < equals));
 126
 127          if (!function)
 128          {
 129             if (equals && (equals < semi))
 130             {
 131                *equals = 0;
 132             }
 133             else
 134             {
 135                *semi = 0;
 136             };
 137             buffer = semi;
 138
 139             strrev(start);
 140             while (isspace(*start)) start++;
 141             strrev(start);
 142          }
 143          else
 144          {
 145             *brace = 0;
 146             buffer = brace;
 147
 148             comma = start;
 149
 150             while (*comma)
 151             {
 152                if (end = strchr(comma, ','))
 153                {
 154                   comma = end;
 155                }
 156                else
 157                {
 158                   comma = strchr(comma, ')');
 159                   if (comma)
 160                   {
 161                      while (end = strchr(comma + 1, ')'))
 162                      {
 163                         comma = end;
 164                      };
 165                   };
 166                };
 167
 168                if (!comma) return;
 169                c = *comma;
 170                *comma = 0;
 171
 172                strrev(start);
 173                while (isspace(*start)) start++;
 174
 175 #if 0
 176                if (strnicmp(start, "diov", 4))
 177                {
 178                   while (iscsym(*start)) start++;
 179                   while (isspace(*start)) start++;
 180                };
 181                strrev(start);
 182
 183                *comma++ = c;
 184
 185                if (c == ')')
 186                {
 187                   *comma = 0;
 188                }
 189                else
 190                {
 191                   end = comma;
 192                   while (isspace(*comma)) comma++;
 193                   if (comma != end)
 194                   {
 195                      *end++ = ' ';
 196                      if (comma != end) strcpy(end, comma);
 197                   };
 198                };
 199             };
 200          };
 201          protomade = TRUE;
 202          FPrintf(hf, "extern %s;\n", start);
 203       };
 204    };
 205    if (!protomade) FPrintf(hf, "/* No external prototypes defined. */\n");
 206 }
 207
 208 int makeprotos(BPTR hf, char **sources)
 209 {
 210    struct AnchorPath *ap;
 211
 212    char *source, *buffer;
 213    BPTR  sf;
 214
 215    if (ap = AllocVec(sizeof(struct AnchorPath) + 512, MEMF_CLEAR))
 216    {
 217       ap->ap_Strlen = 511;
 218
 219       FPrintf(hf, " * Generated by MakeProto\n * ©1996 Ian J. Einman.\n */\n");
 220
 221       while (source = *sources++)
 222       {
 223          if (!MatchFirst(source, ap))
 224          {
 225             do
 226             {
 227                if (sf = Open(ap->ap_Buf, MODE_OLDFILE))
 228                {
 229                   if (buffer = AllocVec(ap->ap_Info.fib_Size + 1, MEMF_CLEAR))
 230                   {
 231                      Read(sf, buffer, ap->ap_Info.fib_Size);
 232                   };
 233                   Close(sf);
 234                   if (buffer)
 235                   {
 236                      FPrintf(hf, "\n/* %-42s */\n\n", ap->ap_Info.fib_FileName);
 237                      makeproto(hf, buffer);
 238                      FreeVec(buffer);
 239                   };
 240                };
 241             }  while (!MatchNext(ap));
 242          };
 243          MatchEnd(ap);
 244       }
 245       FreeVec(ap);
 246
 247       FPrintf(hf, "\n#define makeproto\n");
 248    }
 249    else
 250    {
 251       return 20;
 252    };
 253    return 0;
 254 }
 255
 256 int main(void)
 257 {
 258    int rc = 0;
 259
 260    struct Args
 261    {
 262       char  *Header;
 263       char **Source;
 264    }  args;
 265
 266    struct RDArgs *ra;
 267    BPTR   hf;
 268
 269    args.Header=NULL;
 270    args.Source=NULL;
 271    if (ra = ReadArgs("HEADER/K,SOURCE/M", (LONG *)&args, NULL))
 272    {
 273                 if(args.Source)
 274                 {
 275          if (args.Header
 276          && (hf = Open(args.Header, MODE_NEWFILE)))
 277          {
 278             FPrintf(hf, "/*\n * %s\n *\n", args.Header);
 279             rc = makeprotos(hf, args.Source);
 280             Close(hf);
 281          }
 282          else if ((hf = Output()))
 283          {
 284             FPrintf(hf, "/*\n");
 285             rc = makeprotos(hf, args.Source);
 286          }
 287          else
 288          {
 289             rc = 20;
 290          };
 291       }
 292       else
 293       {
 294          rc = 20;
 295       };
 296       FreeArgs(ra);
 297    };
 298    return rc;
 299 }