soltools/cpp/_cpp.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <time.h>
  24 #include <stdarg.h>
  25 #include "cpp.h"
  26
  27 #define OUTS    16384
  28 static char outbuf[OUTS];
  29 char *outptr = outbuf;
  30 Source *cursource;
  31 static int nerrs;
  32 struct token nltoken = {NL, 0, 1, (uchar *) "\n", 0};
  33 char *curtime;
  34 int incdepth;
  35 int ifdepth;
  36 int ifsatisfied[NIF];
  37 int skipping;
  38
  39 int
  40 #ifdef _WIN32
  41 __cdecl
  42 #endif // _WIN32
  43     main(int argc, char **argv)
  44 {
  45
  46     Tokenrow tr;
  47     time_t t;
  48     char ebuf[BUFSIZ];
  49
  50     setbuf(stderr, ebuf);
  51     t = time(NULL);
  52     curtime = ctime(&t);
  53     maketokenrow(3, &tr);
  54     expandlex();
  55     // coverity[tainted_string] - build time test tool
  56     setup(argc, argv);
  57     fixlex();
  58     if (!Pflag)
  59         genline();
  60     process(&tr);
  61     flushout();
  62     fflush(stderr);
  63     exit(nerrs > 0);
  64 }
  65
  66 void
  67     process(Tokenrow * trp)
  68 {
  69     int anymacros = 0;
  70
  71     for (;;)
  72     {
  73         if (trp->tp >= trp->lp)
  74         {
  75             trp->tp = trp->lp = trp->bp;
  76             outptr = outbuf;
  77             // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
  78             anymacros |= gettokens(trp, 1);
  79             trp->tp = trp->bp;
  80         }
  81         if (trp->tp->type == END)
  82         {
  83             if (--incdepth >= 0)
  84             {
  85                 if (cursource->ifdepth)
  86                     error(ERROR,
  87                           "Unterminated conditional in #include");
  88                 unsetsource();
  89                 cursource->line += cursource->lineinc;
  90                 trp->tp = trp->lp;
  91                 if (!Pflag)
  92                     genline();
  93                 continue;
  94             }
  95             if (ifdepth)
  96                 error(ERROR, "Unterminated #if/#ifdef/#ifndef");
  97             break;
  98         }
  99         if (trp->tp->type == SHARP)
 100         {
 101             trp->tp += 1;
 102             control(trp);
 103         }
 104         else
 105             if (!skipping && anymacros)
 106                 expandrow(trp, NULL);
 107         if (skipping)
 108             setempty(trp);
 109         puttokens(trp);
 110         anymacros = 0;
 111         cursource->line += cursource->lineinc;
 112         if (cursource->lineinc > 1 && !Pflag)
 113             genline();
 114     }
 115 }
 116
 117 void
 118     control(Tokenrow * trp)
 119 {
 120     Nlist *np;
 121     Token *tp;
 122
 123     tp = trp->tp;
 124     if (tp->type != NAME)
 125     {
 126         if (tp->type == NUMBER)
 127             goto kline;
 128         if (tp->type != NL)
 129             error(ERROR, "Unidentifiable control line");
 130         return;                         /* else empty line */
 131     }
 132     if ((np = lookup(tp, 0)) == NULL || ((np->flag & ISKW) == 0 && !skipping))
 133     {
 134         error(WARNING, "Unknown preprocessor control %t", tp);
 135         return;
 136     }
 137     if (skipping)
 138     {
 139         switch (np->val)
 140         {
 141             case KENDIF:
 142                 if (--ifdepth < skipping)
 143                     skipping = 0;
 144                 --cursource->ifdepth;
 145                 setempty(trp);
 146                 return;
 147
 148             case KIFDEF:
 149             case KIFNDEF:
 150             case KIF:
 151                 if (++ifdepth >= NIF)
 152                     error(FATAL, "#if too deeply nested");
 153                 ++cursource->ifdepth;
 154                 return;
 155
 156             case KELIF:
 157             case KELSE:
 158                 if (ifdepth <= skipping)
 159                     break;
 160                 return;
 161
 162             default:
 163                 return;
 164         }
 165     }
 166     switch (np->val)
 167     {
 168         case KDEFINE:
 169             dodefine(trp);
 170             break;
 171
 172         case KUNDEF:
 173             tp += 1;
 174             if (tp->type != NAME || trp->lp - trp->bp != 4)
 175             {
 176                 error(ERROR, "Syntax error in #undef");
 177                 break;
 178             }
 179             if ((np = lookup(tp, 0)) != NULL)
 180             {
 181                 np->flag &= ~ISDEFINED;
 182
 183                 if (Mflag)
 184                 {
 185                     if (np->ap)
 186                         error(INFO, "Macro deletion of %s(%r)", np->name, np->ap);
 187                     else
 188                         error(INFO, "Macro deletion of %s", np->name);
 189                 }
 190             }
 191             break;
 192
 193         case KPRAGMA:
 194         case KIDENT:
 195             for (tp = trp->tp - 1; ((tp->type != NL) && (tp < trp->lp)); tp++)
 196                 tp->type = UNCLASS;
 197             return;
 198
 199         case KIFDEF:
 200         case KIFNDEF:
 201         case KIF:
 202             if (++ifdepth >= NIF)
 203                 error(FATAL, "#if too deeply nested");
 204             ++cursource->ifdepth;
 205             ifsatisfied[ifdepth] = 0;
 206             if (eval(trp, np->val))
 207                 ifsatisfied[ifdepth] = 1;
 208             else
 209                 skipping = ifdepth;
 210             break;
 211
 212         case KELIF:
 213             if (ifdepth == 0)
 214             {
 215                 error(ERROR, "#elif with no #if");
 216                 return;
 217             }
 218             if (ifsatisfied[ifdepth] == 2)
 219                 error(ERROR, "#elif after #else");
 220             if (eval(trp, np->val))
 221             {
 222                 if (ifsatisfied[ifdepth])
 223                     skipping = ifdepth;
 224                 else
 225                 {
 226                     skipping = 0;
 227                     ifsatisfied[ifdepth] = 1;
 228                 }
 229             }
 230             else
 231                 skipping = ifdepth;
 232             break;
 233
 234         case KELSE:
 235             if (ifdepth == 0 || cursource->ifdepth == 0)
 236             {
 237                 error(ERROR, "#else with no #if");
 238                 return;
 239             }
 240             if (ifsatisfied[ifdepth] == 2)
 241                 error(ERROR, "#else after #else");
 242             if (trp->lp - trp->bp != 3)
 243                 error(ERROR, "Syntax error in #else");
 244             skipping = ifsatisfied[ifdepth] ? ifdepth : 0;
 245             ifsatisfied[ifdepth] = 2;
 246             break;
 247
 248         case KENDIF:
 249             if (ifdepth == 0 || cursource->ifdepth == 0)
 250             {
 251                 error(ERROR, "#endif with no #if");
 252                 return;
 253             }
 254             --ifdepth;
 255             --cursource->ifdepth;
 256             if (trp->lp - trp->bp != 3)
 257                 error(WARNING, "Syntax error in #endif");
 258             break;
 259
 260         case KERROR:
 261             trp->tp = tp + 1;
 262             error(WARNING, "#error directive: %r", trp);
 263             break;
 264
 265         case KLINE:
 266             trp->tp = tp + 1;
 267             expandrow(trp, "<line>");
 268             tp = trp->bp + 2;
 269     kline:
 270             if (tp + 1 >= trp->lp || tp->type != NUMBER || tp + 3 < trp->lp
 271                 || (tp + 3 == trp->lp
 272                     && ((tp + 1)->type != STRING || *(tp + 1)->t == 'L')))
 273             {
 274                 error(ERROR, "Syntax error in #line");
 275                 return;
 276             }
 277             cursource->line = atol((char *) tp->t) - 1;
 278             if (cursource->line < 0 || cursource->line >= 32768)
 279                 error(WARNING, "#line specifies number out of range");
 280             tp = tp + 1;
 281             if (tp + 1 < trp->lp)
 282                 cursource->filename = (char *) newstring(tp->t + 1, tp->len - 2, 0);
 283             return;
 284
 285         case KDEFINED:
 286             error(ERROR, "Bad syntax for control line");
 287             break;
 288
 289         case KIMPORT:
 290             doinclude(trp, -1, 1);
 291             trp->lp = trp->bp;
 292             return;
 293
 294         case KINCLUDE:
 295             doinclude(trp, -1, 0);
 296             trp->lp = trp->bp;
 297             return;
 298
 299         case KINCLUDENEXT:
 300             doinclude(trp, cursource->pathdepth, 0);
 301             trp->lp = trp->bp;
 302             return;
 303
 304         case KEVAL:
 305             eval(trp, np->val);
 306             break;
 307
 308         default:
 309             error(ERROR, "Preprocessor control `%t' not yet implemented", tp);
 310             break;
 311     }
 312     setempty(trp);
 313     return;
 314 }
 315
 316 void *
 317     domalloc(size_t size)
 318 {
 319     void *p = malloc(size);
 320
 321     if (p == NULL)
 322         error(FATAL, "Out of memory from malloc");
 323     return p;
 324 }
 325
 326 void
 327     dofree(void *p)
 328 {
 329     free(p);
 330 }
 331
 332 void
 333     error(enum errtype type, char *string,...)
 334 {
 335     va_list ap;
 336     char c, *cp, *ep;
 337     Token *tp;
 338     Tokenrow *trp;
 339     Source *s;
 340     int i;
 341
 342     fprintf(stderr, "cpp: ");
 343     for (s = cursource; s; s = s->next)
 344         if (*s->filename)
 345             fprintf(stderr, "%s:%d ", s->filename, s->line);
 346     va_start(ap, string);
 347     for (ep = string; *ep; ep++)
 348     {
 349         if (*ep == '%')
 350         {
 351             switch (*++ep)
 352             {
 353
 354                 case 'c':
 355                     c = (char) va_arg(ap, int);
 356                     fprintf(stderr, "%c", c);
 357                     break;
 358
 359                 case 's':
 360                     cp = va_arg(ap, char *);
 361                     fprintf(stderr, "%s", cp);
 362                     break;
 363
 364                 case 'd':
 365                     i = va_arg(ap, int);
 366                     fprintf(stderr, "%d", i);
 367                     break;
 368
 369                 case 't':
 370                     tp = va_arg(ap, Token *);
 371                     fprintf(stderr, "%.*s", (int)tp->len, tp->t);
 372                     break;
 373
 374                 case 'r':
 375                     trp = va_arg(ap, Tokenrow *);
 376                     for (tp = trp->tp; tp < trp->lp && tp->type != NL; tp++)
 377                     {
 378                         if (tp > trp->tp && tp->wslen)
 379                             fputc(' ', stderr);
 380                         fprintf(stderr, "%.*s", (int)tp->len, tp->t);
 381                     }
 382                     break;
 383
 384                 default:
 385                     fputc(*ep, stderr);
 386                     break;
 387             }
 388         }
 389         else
 390             fputc(*ep, stderr);
 391     }
 392     va_end(ap);
 393     fputc('\n', stderr);
 394     if (type == FATAL)
 395         exit(1);
 396     if (type != WARNING)
 397         nerrs = 1;
 398     fflush(stderr);
 399 }
 400
 401 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */