/home/maarten/src/libreoffice/core/soltools/cpp/_macro.c

Bug Summary

File:	home/maarten/src/libreoffice/core/soltools/cpp/_macro.c
Warning:	line 726, column 33 Access to field 'line' results in a dereference of a null pointer (loaded from variable 's')

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name _macro.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -std=gnu89 -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -stack-protector 2 -fgnuc-version=4.2.1 -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c /home/maarten/src/libreoffice/core/soltools/cpp/_macro.c

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <stdio.h>
21#include <stdlib.h>
22#include <string.h>
23#if defined(__IBMC__) || defined(__EMX__) || defined(_MSC_VER)
24#   ifndef PATH_MAX4096
25#       define PATH_MAX4096 _MAX_PATH
26#   endif
27#endif
28#include <limits.h>

30#include "cpp.h"

32#define NCONCAT16384 16384

34/*
* do a macro definition.  tp points to the name being defined in the line
*/
37void
  dodefine(Tokenrow * trp)
39{
  Token *tp;
  Nlist *np;
  Source *s;
  Tokenrow *def, *args;
  static uchar location[(PATH_MAX4096 + 8) * NINC32], *cp;

  tp = trp->tp + 1;
  if (tp >= trp->lp || tp->type != NAME)
  {
      error(ERROR, "#defined token is not a name");
      return;
  }
  np = lookup(tp, 1);
  if (np->flag & ISUNCHANGE0x04)
  {
      error(ERROR, "#defined token %t can't be redefined", tp);
      return;
  }
  /* collect arguments */
  tp += 1;
  args = NULL((void*)0);
  if (tp < trp->lp && tp->type == LP && tp->wslen == 0)
  {
      tp += 1;
      args = new(Tokenrow)(Tokenrow *)domalloc(sizeof(Tokenrow));
      maketokenrow(2, args);
      if (tp->type != RP)
      {
          /* macro with args */
          size_t narg = 0;
          int err = 0;

          for (;;)
          {
              Token *atp;

              if (tp->type != NAME)
              {
                  err++;
                  break;
              }
              if (narg >= args->max)
                  growtokenrow(args);
              for (atp = args->bp; atp < args->lp; atp++)
                  if (atp->len == tp->len
                      && strncmp((char *) atp->t, (char *) tp->t, tp->len) == 0)
                      error(ERROR, "Duplicate macro argument");
              *args->lp++ = *tp;
              narg++;
              tp += 1;
              if (tp->type == RP)
                  break;
              if (tp->type != COMMA)
              {
                  err++;
                  break;
              }
              tp += 1;
          }
          if (err)
          {
              error(ERROR, "Syntax error in macro parameters");
              return;
          }
      }
      tp += 1;
  }
  trp->tp = tp;
  if (((trp->lp) - 1)->type == NL)
      trp->lp -= 1;
  def = normtokenrow(trp);
  if (np->flag & ISDEFINED0x01)
  {
      if (comparetokens(def, np->vp)
          || (np->ap == NULL((void*)0)) != (args == NULL((void*)0))
          || (np->ap && comparetokens(args, np->ap)))
      {
          if ( np->loc )
              error(ERROR,
                  "Macro redefinition of %t (already defined at %s)",
                  trp->bp + 2, np->loc);
          else
              error(ERROR,
                  "Macro redefinition of %t (already defined at %s)",
                  trp->bp + 2, "commandline" );
      }
  }
  if (args)
  {
      Tokenrow *tap;

      tap = normtokenrow(args);
      dofree(args->bp);
      dofree(args);
      args = tap;
  }
  np->ap = args;
  np->vp = def;
  np->flag |= ISDEFINED0x01;

  /* build location string of macro definition */
  for (cp = location, s = cursource; s; s = s->next)
      if (*s->filename)
      {
          if (cp != location)
              *cp++ = ' ';
          sprintf((char *)cp, "%s:%d", s->filename, s->line);
          cp += strlen((char *)cp);
      }

  np->loc = newstring(location, strlen((char *)location), 0);

  if (Mflag)
  {
      if (np->ap)
          error(INFO, "Macro definition of %s(%r) [%r]", np->name, np->ap, np->vp);
      else
          error(INFO, "Macro definition of %s [%r]", np->name, np->vp);
  }
159}

161/*
* Definition received via -D or -U
*/
164void
  doadefine(Tokenrow * trp, int type)
166{
  Nlist *np;
  static uchar onestr[2] = "1";
  static Token onetoken[1] = {{NUMBER, 0, 1, onestr, 0}};
  static Tokenrow onetr = {onetoken, onetoken, onetoken + 1, 1};

  trp->tp = trp->bp;
  if (type == 'U')
  {
      if (trp->lp - trp->tp != 2 || trp->tp->type != NAME)
          goto syntax;
      if ((np = lookup(trp->tp, 0)) == NULL((void*)0))
          return;
      np->flag &= ~ISDEFINED0x01;
      return;
  }

  if (type == 'A')
  {
      if (trp->tp >= trp->lp || trp->tp->type != NAME)
          goto syntax;
      trp->tp->type = ARCHITECTURE;
      np = lookup(trp->tp, 1);
      np->flag |= ISARCHITECTURE0x10;
      trp->tp += 1;
      if (trp->tp >= trp->lp || trp->tp->type == END)
      {
          np->vp = &onetr;
          return;
      }
      else
          error(FATAL, "Illegal -A argument %r", trp);
  }

  if (trp->tp >= trp->lp || trp->tp->type != NAME)
      goto syntax;
  np = lookup(trp->tp, 1);
  np->flag |= ISDEFINED0x01;
  trp->tp += 1;
  if (trp->tp >= trp->lp || trp->tp->type == END)
  {
      np->vp = &onetr;
      return;
  }
  if (trp->tp->type != ASGN)
      goto syntax;
  trp->tp += 1;
  if ((trp->lp - 1)->type == END)
      trp->lp -= 1;
  np->vp = normtokenrow(trp);
  return;
217syntax:
  error(FATAL, "Illegal -D or -U argument %r", trp);
219}



223/*
* Do macro expansion in a row of tokens.
* Flag is NULL if more input can be gathered.
*/
227void
  expandrow(Tokenrow * trp, char *flag)
229{
  Token * tp;
  Nlist * np;

  MacroValidatorList  validators;
  mvl_init(&validators);
  /* Sets all token-identifiers to 0 because tokens may not be initialised (never use C!) */
  tokenrow_zeroTokenIdentifiers(trp);

  if (flag)
1
Assuming 'flag' is null→
2
←
Taking false branch→
      setsource(flag, -1, -1, "", 0);
  for (tp = trp->tp; tp < trp->lp;)
3
←
Assuming 'tp' is < field 'lp'→
4
←
Loop condition is true.  Entering loop body→
  {
      mvl_check(&validators, tp);

      if (tp->type != NAME
5
←
Assuming field 'type' is equal to NAME→
13
←
Taking false branch→
          || quicklook(tp->t[0], tp->len > 1 ? tp->t[1] : 0)(namebit[(tp->t[0])&077] & (1U<<((tp->len
 > 1 ? tp->t[1] : 0)&037))) == 0
6
←
Assuming field 'len' is <= 1→
7
←
'?' condition is false→
8
←
Assuming the condition is false→
          || (np = lookup(tp, 0)) == NULL((void*)0)
9
←
Value assigned to 'cursource'→
10
←
Assuming the condition is false→
          || (np->flag & (ISDEFINED0x01 | ISMAC0x08)) == 0
11
←
Assuming the condition is false→
          || (np->flag & ISACTIVE0x80) != 0)
12
←
Assuming the condition is false→
      {
          tp++;
          continue;
      }
      trp->tp = tp;
      if (np->val == KDEFINED)
14
←
Assuming field 'val' is not equal to KDEFINED→
15
←
Taking false branch→
      {
          tp->type = DEFINED;
          if ((tp + 1) < trp->lp && (tp + 1)->type == NAME)
              (tp + 1)->type = NAME1;
          else
              if ((tp + 3) < trp->lp && (tp + 1)->type == LP
                  && (tp + 2)->type == NAME && (tp + 3)->type == RP)
                  (tp + 2)->type = NAME1;
              else
                  error(ERROR, "Incorrect syntax for `defined'");
          tp++;
          continue;
      }
      else
          if (np->val == KMACHINE)
16
←
Assuming field 'val' is not equal to KMACHINE→
17
←
Taking false branch→
          {
              if (((tp - 1) >= trp->bp) && ((tp - 1)->type == SHARP))
              {
                  tp->type = ARCHITECTURE;
                  if ((tp + 1) < trp->lp && (tp + 1)->type == NAME)
                      (tp + 1)->type = NAME2;
                  else
                      if ((tp + 3) < trp->lp && (tp + 1)->type == LP
                          && (tp + 2)->type == NAME && (tp + 3)->type == RP)
                          (tp + 2)->type = NAME2;
                      else
                          error(ERROR, "Incorrect syntax for `#machine'");
              }
              tp++;
              continue;
          }

      if (np->flag & ISMAC0x08)
18
←
Assuming the condition is true→
19
←
Taking true branch→
          builtin(trp, np->val);
20
←
Calling 'builtin'→
      else
      {
          // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
          expand(trp, np, &validators);
      }
      tp = trp->tp;
  }   // end for
  if (flag)
      unsetsource();

  mvl_destruct(&validators);
300}

302/*
* Expand the macro whose name is np, at token trp->tp, in the tokenrow.
* Return trp->tp at the first token next to be expanded
* (ordinarily the beginning of the expansion)
* I.e.: the same position as before!
* Only one expansion is performed, then we return to the expandrow()
* loop and start at same position.
*/
310void
  expand(Tokenrow * trp, Nlist * np, MacroValidatorList * pValidators)
312{
  Tokenrow ntr;
  int ntokc, narg;
  Tokenrow *atr[NARG32 + 1];

  if (Mflag == 2)
  {
      if (np->ap)
          error(INFO, "Macro expansion of %t with %s(%r)", trp->tp, np->name, np->ap);
      else
          error(INFO, "Macro expansion of %t with %s", trp->tp, np->name);
  }

  copytokenrow(&ntr, np->vp);         /* copy macro value */
  if (np->ap == NULL((void*)0))                 /* parameterless */
      ntokc = 1;
  else
  {
      int i;

      ntokc = gatherargs(trp, atr, &narg);
      if (narg < 0)
      {                               /* not actually a call (no '(') */
          trp->tp++;
          return;
      }
      if (narg != rowlen(np->ap)((np->ap)->lp - (np->ap)->bp))
      {
          error(ERROR, "Disagreement in number of macro arguments");
          trp->tp += ntokc;
          return;
      }

      /** If gatherargs passed a macro validating token, this token
          must become valid here.
          trp->tp+0 was checked in expandrow(), so we don't need to do it
          again here:
      */
      for (i = 1; i < ntokc; i++)
      {
          mvl_check(pValidators,trp->tp+i);
      }

      substargs(np, &ntr, atr);       /* put args into replacement */
      for (i = 0; i < narg; i++)
      {
          dofree(atr[i]->bp);
          dofree(atr[i]);
      }
  }

  doconcat(&ntr);                     /* execute ## operators */
  ntr.tp = ntr.bp;
  makespace(&ntr, trp->tp);

  tokenrow_zeroTokenIdentifiers(&ntr);
  insertrow(trp, ntokc, &ntr);

      /* add validator for just invalidated macro:
      */
  np->flag |= ISACTIVE0x80;
  if (trp->tp != trp->lp)
  {   /* tp is a valid pointer: */
      mvl_add(pValidators,np,trp->tp);
  }
  else
  {   /* tp is == lp, therefore does not point to valid memory: */
      mvl_add(pValidators,np,NULL((void*)0));
  }
      /* reset trp->tp to original position:
      */
  trp->tp -= ntr.lp - ntr.bp;         /* so the result will be tested for macros from the same position again */

  dofree(ntr.bp);

  return;
388}

390/*
* Gather an arglist, starting in trp with tp pointing at the macro name.
* Return total number of tokens passed, stash number of args found.
* trp->tp is not changed relative to the tokenrow.
*/
395int
  gatherargs(Tokenrow * trp, Tokenrow ** atr, int *narg)
397{
  int parens = 1;
  int ntok = 0;
  Token *bp, *lp;
  Tokenrow ttr;
  int ntokp;
  int needspace;

  *narg = -1;                         /* means that there is no macro
                                       * call */
  /* look for the ( */
  for (;;)
  {
      trp->tp++;
      ntok++;
      if (trp->tp >= trp->lp)
      {
          // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
          gettokens(trp, 0);
          if ((trp->lp - 1)->type == END)
          {
              trp->lp -= 1;
              trp->tp -= ntok;
              return ntok;
          }
      }
      if (trp->tp->type == LP)
          break;
      if (trp->tp->type != NL)
          return ntok;
  }
  *narg = 0;
  ntok++;
  ntokp = ntok;
  trp->tp++;
  /* search for the terminating ), possibly extending the row */
  needspace = 0;
  while (parens > 0)
  {
      if (trp->tp >= trp->lp)
      {
          // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
          gettokens(trp, 0);
      }
      if (needspace)
      {
          needspace = 0;
          /* makespace(trp); [rh] */
      }
      if (trp->tp->type == END)
      {
          trp->lp -= 1;
          trp->tp -= ntok;
          error(ERROR, "EOF in macro arglist");
          return ntok;
      }
      if (trp->tp->type == NL)
      {
          trp->tp += 1;
          adjustrow(trp, -1);
          trp->tp -= 1;
          /* makespace(trp); [rh] */
          needspace = 1;
          continue;
      }
      if (trp->tp->type == LP)
          parens++;
      else
          if (trp->tp->type == RP)
              parens--;
      trp->tp++;
      ntok++;
  }
  trp->tp -= ntok;
  /* Now trp->tp won't move underneath us */
  lp = bp = trp->tp + ntokp;
  for (; parens >= 0; lp++)
  {
      if (lp->type == LP)
      {
          parens++;
          continue;
      }
      if (lp->type == RP)
          parens--;
      if (lp->type == DSHARP)
          lp->type = DSHARP1;         /* ## not special in arg */
      if ((lp->type == COMMA && parens == 0) ||
              ( parens < 0 && ((lp - 1)->type != LP)))
      {
          if (*narg >= NARG32 - 1)
              error(FATAL, "Sorry, too many macro arguments");
          ttr.bp = ttr.tp = bp;
          ttr.lp = lp;
          atr[(*narg)++] = normtokenrow(&ttr);
          bp = lp + 1;
      }
  }
  return ntok;
496}

498/*
* substitute the argument list into the replacement string
*  This would be simple except for ## and #
*/
502void
  substargs(Nlist * np, Tokenrow * rtr, Tokenrow ** atr)
504{
  Tokenrow tatr;
  Token *tp;
  int ntok, argno;

  for (rtr->tp = rtr->bp; rtr->tp < rtr->lp;)
  {
      if (rtr->tp->type == SHARP)
      {                               /* string operator */
          tp = rtr->tp;
          rtr->tp += 1;
          if ((argno = lookuparg(np, rtr->tp)) < 0)
          {
              error(ERROR, "# not followed by macro parameter");
              continue;
          }
          ntok = 1 + (int)(rtr->tp - tp);
          rtr->tp = tp;
          insertrow(rtr, ntok, stringify(atr[argno]));
          continue;
      }
      if (rtr->tp->type == NAME
          && (argno = lookuparg(np, rtr->tp)) >= 0)
      {
          if (((rtr->tp + 1) < rtr->lp && (rtr->tp + 1)->type == DSHARP)
              || (rtr->tp != rtr->bp  && (rtr->tp - 1)->type == DSHARP))
          {
              copytokenrow(&tatr, atr[argno]);
              makespace(&tatr, rtr->tp);
              insertrow(rtr, 1, &tatr);
              dofree(tatr.bp);
          }
          else
          {
              copytokenrow(&tatr, atr[argno]);
              makespace(&tatr, rtr->tp);
              expandrow(&tatr, "<macro>");
              insertrow(rtr, 1, &tatr);
              dofree(tatr.bp);
          }
          continue;
      }
      rtr->tp++;
  }
548}

550/*
* Evaluate the ## operators in a tokenrow
*/
553void
  doconcat(Tokenrow * trp)
555{
  Token *ltp, *ntp;
  Tokenrow ntr;
  size_t len;

  for (trp->tp = trp->bp; trp->tp < trp->lp; trp->tp++)
  {
      if (trp->tp->type == DSHARP1)
          trp->tp->type = DSHARP;
      else
          if (trp->tp->type == DSHARP)
          {
              int  i;
              char tt[NCONCAT16384];

              ltp = trp->tp - 1;
              ntp = trp->tp + 1;

              if (ltp < trp->bp || ntp >= trp->lp)
              {
                  error(ERROR, "## occurs at border of replacement");
                  continue;
              }

              ntp = ltp;
              i   = 1;
              len = 0;

              do
              {
                  if (len + ntp->len + ntp->wslen > sizeof(tt))
                  {
                      error(ERROR, "## string concatenation buffer overrun");
                      break;
                  }

                  if (ntp != trp->tp + 1)
                  {
                      strncpy((char *) tt + len, (char *) ntp->t - ntp->wslen,
                              ntp->len + ntp->wslen);
                      len += ntp->len + ntp->wslen;
                  }
                  else
                  {
                      // remove spaces around ##
                      strncpy((char *) tt + len, (char *) ntp->t, ntp->len);
                      len += ntp->len;
                  }

                  ntp = trp->tp + i;
                  i++;
              }
              while (ntp < trp->lp);

              tt[len] = '\0';
              setsource("<##>", -1, -1, tt, 0);
              maketokenrow(3, &ntr);
              // coverity[overrun-buffer-arg: FALSE] - a multiple of trp->max is allocated, not trp->max itself
              gettokens(&ntr, 1);
              unsetsource();
              if (ntr.bp->type == UNCLASS)
                  error(WARNING, "Bad token %r produced by ##", &ntr);
              while ((ntr.lp-1)->len == 0 && ntr.lp != ntr.bp)
                  ntr.lp--;

              doconcat(&ntr);
              trp->tp = ltp;
              makespace(&ntr, ltp);
              insertrow(trp, (int)(ntp - ltp), &ntr);
              dofree(ntr.bp);
              trp->tp--;
          }
  }
628}

630/*
* tp is a potential parameter name of macro mac;
* look it up in mac's arglist, and if found, return the
* corresponding index in the argname array.  Return -1 if not found.
*/
635int
  lookuparg(Nlist * mac, Token const * tp)
637{
  Token *ap;

  if (tp->type != NAME || mac->ap == NULL((void*)0))
      return -1;
  for (ap = mac->ap->bp; ap < mac->ap->lp; ap++)
  {
      if (ap->len == tp->len && strncmp((char *) ap->t, (char *) tp->t, ap->len) == 0)
          return (int)(ap - mac->ap->bp);
  }
  return -1;
648}

650/*
* Return a quoted version of the tokenrow (from # arg)
*/
653#define STRLEN512  512
654Tokenrow *
  stringify(Tokenrow * vp)
656{
  static Token t = {STRING, 0, 0, NULL((void*)0), 0};
  static Tokenrow tr = {&t, &t, &t + 1, 1};
  Token *tp;
  uchar s[STRLEN512];
  uchar *sp = s, *cp;
  int i, instring;

  *sp++ = '"';
  for (tp = vp->bp; tp < vp->lp; tp++)
  {
      instring = tp->type == STRING || tp->type == CCON;
      if (sp + 2 * tp->len + tp->wslen  >= &s[STRLEN512 - 10])
      {
          error(ERROR, "Stringified macro arg is too long");
          break;
      }

      // Change by np 31.10.2001, #93725 - begin
      if ( tp->wslen > 0 )
          *sp++ = ' ';
      // change end.

      for (i = 0, cp = tp->t; (unsigned int)i < tp->len; i++)
      {
          if (instring && (*cp == '"' || *cp == '\\'))
              *sp++ = '\\';
          *sp++ = *cp++;
      }
  }
  *sp++ = '"';
  *sp = '\0';
  sp = s;
  t.len = strlen((char *) sp);
  t.t = newstring(sp, t.len, 0);
  return &tr;
692}

694/*
* expand a builtin name
*/
697void
  builtin(Tokenrow * trp, int biname)
699{
  char *op;
  Token *tp;
  Source *s;

  tp = trp->tp;
  trp->tp++;
  /* need to find the real source */
  s = cursource;
  while (s && s->fd == -1)
21
←
Assuming 's' is null→
      s = s->next;
  if (s21.1
's' is equal to NULL
 == NULL((void*)0))
22
←
Taking true branch→
      s = cursource;
23
←
Null pointer value stored to 's'→
  /* most are strings */
  tp->type = STRING;
  if (tp->wslen)
24
←
Assuming field 'wslen' is 0→
25
←
Taking false branch→
  {
      *outptr++ = ' ';
      tp->wslen = 1;
  }
  op = outptr;
  *op++ = '"';
  switch (biname)
26
←
Control jumps to 'case KLINENO:'  at line 724→
  {

      case KLINENO:
          tp->type = NUMBER;
          op = outnum(op - 1, s->line);
27
←
Access to field 'line' results in a dereference of a null pointer (loaded from variable 's')
          break;

      case KFILE:
          {
              char *src = s->filename;

              while ((*op++ = *src++) != 0)
                  if (src[-1] == '\\')
                      *op++ = '\\';
              op--;
              break;
          }

      case KDATE:
          strncpy(op, curtime + 4, 7);
          strncpy(op + 7, curtime + 20, 4);
          op += 11;
          break;

      case KTIME:
          strncpy(op, curtime + 11, 8);
          op += 8;
          break;

      default:
          error(ERROR, "cpp botch: unknown internal macro");
          return;
  }
  if (tp->type == STRING)
      *op++ = '"';
  tp->t = (uchar *) outptr;
  tp->len = op - outptr;
  outptr = op;
760}

762/* vim:set shiftwidth=4 softtabstop=4 expandtab: */