/*
** LCLint - annotation-assisted static program checker
-** Copyright (C) 1994-2000 University of Virginia,
+** Copyright (C) 1994-2001 University of Virginia,
** Massachusetts Institute of Technology
**
** This program is free software; you can redistribute it and/or modify it
# include "portab.h"
extern /*@external@*/ int yydebug;
+extern /*@external@*/ int mtdebug;
typedef struct
{
} maccesst;
typedef enum {
+ CX_ERROR,
+
CX_GLOBAL, CX_INNER,
- CX_FUNCTION, CX_FCNDECL,
+ CX_FUNCTION, CX_FCNDECLARATION,
CX_MACROFCN, CX_MACROCONST, CX_UNKNOWNMACRO,
- CX_ITERDEF, CX_ITEREND,
- CX_LCL, CX_LCLLIB
+ CX_ITERDEF, CX_ITEREND,
+ CX_OLDSTYLESCOPE, /* Parsing old-style parameter declarations */
+ CX_LCL, CX_LCLLIB, CX_MT
} kcontext;
-static struct _context
+static struct
{
int linesprocessed;
int speclinesprocessed;
bool savedFlags BOOLBITS;
bool justpopped BOOLBITS;
bool anyExports BOOLBITS;
+ bool inFunctionHeader BOOLBITS;
flagcode library;
int counters[NUMVALUEFLAGS];
o_cstring strings[NUMSTRINGFLAGS];
- sRefSetList modrecs;
+ sRefSetList modrecs; /*@i32 ???? what is this for? */
- union
+ metaStateTable stateTable; /* User-defined state information. */
+ annotationTable annotTable; /* User-defined annotations table. */
+ union u_cont
{
bool glob;
int cdepth;
/*@dependent@*/ /*@exposed@*/ uentry fcn;
} cont;
+
+ kcontext savekind;
+ union u_cont savecont;
} gc;
static /*@exposed@*/ cstring context_exposeString (flagcode p_flag) ;
return gc.preprocessing;
}
+bool context_loadingLibrary (void)
+{
+ return (fileloc_isLib (g_currentloc));
+}
+
+bool context_inXHFile (void)
+{
+ return (fileloc_isXHFile (g_currentloc));
+}
+
void context_setInCommandLine (void)
{
llassert (!gc.incommandline);
void
context_addMacroCache (/*@only@*/ cstring def)
{
- macrocache_addEntry (gc.mc, fileloc_copy (g_currentloc), def);
+ DPRINTF (("macro cache: %s", def));
+ macrocache_addEntry (gc.mc, fileloc_copy (g_currentloc), def);
}
void
context_addComment (/*@only@*/ cstring def)
{
- macrocache_addComment (gc.mc, fileloc_copy (g_currentloc), def);
+ DPRINTF (("macro comment: %s", def));
+ macrocache_addComment (gc.mc, fileloc_copy (g_currentloc), def);
}
/*
return TRUE;
}
+ DPRINTF (("Checking suppress: %s / %s", fileloc_unparse (fl), fileloc_unparse (g_currentloc)));
+
/* want same object compare here */
if (fileloc_equal (fl, g_currentloc) || gc.inDerivedFile)
{
+ DPRINTF (("In derived file: %s", bool_unparse (gc.inDerivedFile)));
+
return (!context_getFlag (flag)
|| context_inSuppressRegion ()
|| context_inSuppressZone (fl)
- || (gc.inDerivedFile && context_inSuppressFlagZone (fl, flag)));
+ || (/*@!@@#@ gc.inDerivedFile && */ context_inSuppressFlagZone (fl, flag)));
}
else
{
- return (context_inSuppressFlagZone (fl, flag));
+ return (context_inSuppressFlagZone (fl, flag));
}
}
flagMarkerList_add (gc.markers, flagMarker_createIgnoreOff (g_currentloc));
}
+void
+context_enterMTfile (void)
+{
+ gc.kind = CX_MT;
+}
+
+void
+context_exitMTfile (void)
+{
+ llassert (gc.kind == CX_MT);
+ gc.kind = CX_GLOBAL;
+}
+
# ifndef NOLCL
void
context_enterLCLfile (void)
{
if (gc.kind != CX_LCLLIB)
{
- char *lclname =
- removeExtension (cstring_toCharsSafe
- (fileName (currentFile ())), ".lcl");
-
- addModuleAccess (cstring_fromCharsO (removePath (lclname)), gc.facct);
+ cstring lclname =
+ fileLib_withoutExtension (fileName (currentFile ()), LCL_EXTENSION);
- mstring_free (lclname);
+ addModuleAccess (fileLib_removePath (lclname), gc.facct);
+ cstring_free (lclname);
}
gc.kind = CX_LCL;
gc.library = code;
}
-/*@observer@*/ char *context_selectedLibrary ()
+/*@observer@*/ cstring context_selectedLibrary ()
{
switch (gc.library)
{
case FLG_STRICTLIB:
- return LLSTRICTLIBS_NAME;
+ return cstring_makeLiteralTemp (LLSTRICTLIBS_NAME);
case FLG_POSIXLIB:
- return LLPOSIXLIBS_NAME;
+ return cstring_makeLiteralTemp (LLPOSIXLIBS_NAME);
case FLG_POSIXSTRICTLIB:
- return LLPOSIXSTRICTLIBS_NAME;
+ return cstring_makeLiteralTemp (LLPOSIXSTRICTLIBS_NAME);
case FLG_UNIXLIB:
- return LLUNIXLIBS_NAME;
+ return cstring_makeLiteralTemp (LLUNIXLIBS_NAME);
case FLG_UNIXSTRICTLIB:
- return LLUNIXSTRICTLIBS_NAME;
+ return cstring_makeLiteralTemp (LLUNIXSTRICTLIBS_NAME);
case FLG_ANSILIB:
- return LLSTDLIBS_NAME;
+ return cstring_makeLiteralTemp (LLSTDLIBS_NAME);
BADDEFAULT;
}
}
char *os = s;
# endif
- while (fgets (s, MAX_DUMP_LINE_LENGTH, in) != NULL
+ while ((reader_readLine (in, s, MAX_DUMP_LINE_LENGTH) != NULL )
&& *s == ';')
{
;
addModuleAccess (cstring_copy (cstring_fromChars (oname)),
typeIdSet_undump (&s));
- (void) fgets (s, MAX_DUMP_LINE_LENGTH, in);
+ (void) reader_readLine (in, s, MAX_DUMP_LINE_LENGTH);
llassert (s != lasts);
lasts = s;
}
}
void
-context_resetAllFlags (void)
+context_resetAllFlags (void)
{
allFlagCodes (code)
{
{
case FLG_LIMIT:
val = DEFAULT_LIMIT; break;
+ case FLG_BUGSLIMIT:
+ val = DEFAULT_BUGSLIMIT; break;
case FLG_LINELEN:
val = DEFAULT_LINELEN; break;
+ case FLG_INDENTSPACES:
+ val = DEFAULT_INDENTSPACES; break;
case FLG_EXTERNALNAMELEN:
val = DEFAULT_EXTERNALNAMELEN; break;
case FLG_INTERNALNAMELEN:
{ /*@-loopswitchbreak@*/
case FLG_LARCHPATH:
{
- char *larchpath = osd_getEnvironmentVariable (LARCH_PATH);
+ cstring larchpath = osd_getEnvironmentVariable (LARCH_PATH);
- if (larchpath != NULL)
+ if (cstring_isDefined (larchpath))
{
- val = cstring_fromCharsNew (larchpath);
+ val = cstring_copy (larchpath);
}
else
{
}
case FLG_LCLIMPORTDIR:
{
- val = cstring_fromCharsNew (osd_getEnvironment (LCLIMPORTDIR, DEFAULT_LCLIMPORTDIR));
+ val = cstring_copy (osd_getEnvironment (cstring_makeLiteralTemp (LCLIMPORTDIR), cstring_makeLiteralTemp (DEFAULT_LCLIMPORTDIR)));
break;
}
case FLG_TMPDIR:
** These flags are true by default.
*/
+ /*@i34 move this into flags.def */
+
gc.flags[FLG_MODIFIES] = TRUE;
gc.flags[FLG_NESTCOMMENT] = TRUE;
gc.flags[FLG_GLOBALS] = TRUE;
gc.flags[FLG_FULLINITBLOCK] = TRUE;
+ gc.flags[FLG_INITSIZE] = TRUE;
+ gc.flags[FLG_INITALLELEMENTS] = TRUE;
+
+ gc.flags[FLG_STRINGLITTOOLONG] = TRUE;
+
gc.flags[FLG_LIKELYBOOL] = TRUE;
gc.flags[FLG_ZEROPTR] = TRUE;
gc.flags[FLG_NUMLITERAL] = TRUE;
gc.flags[FLG_SKIPPOSIXHEADERS] = TRUE;
gc.flags[FLG_SYSTEMDIREXPAND] = TRUE;
gc.flags[FLG_UNRECOGCOMMENTS] = TRUE;
+ gc.flags[FLG_UNRECOGFLAGCOMMENTS] = TRUE;
gc.flags[FLG_CASTFCNPTR] = TRUE;
gc.flags[FLG_DOLCS] = TRUE;
gc.flags[FLG_USEVARARGS] = TRUE;
gc.flags[FLG_SIZEOFFORMALARRAY] = TRUE;
gc.flags[FLG_FIXEDFORMALARRAY] = TRUE;
+ gc.flags[FLG_WARNUSE] = TRUE;
gc.flags[FLG_PREDASSIGN] = TRUE;
gc.flags[FLG_MODOBSERVER] = TRUE;
gc.flags[FLG_MACROVARPREFIXEXCLUDE] = TRUE;
gc.flags[FLG_FORMATTYPE] = TRUE;
gc.flags[FLG_BADFLAG] = TRUE;
gc.flags[FLG_WARNFLAGS] = TRUE;
+ gc.flags[FLG_FILEEXTENSIONS] = TRUE;
gc.flags[FLG_WARNUNIXLIB] = TRUE;
gc.flags[FLG_WARNPOSIX] = TRUE;
gc.flags[FLG_SHOWCOL] = TRUE;
gc.flags[FLG_ACCESSFILE] = TRUE;
gc.flags[FLG_MACROVARPREFIX] = TRUE;
+ gc.flags[FLG_ANNOTATIONERROR] = TRUE;
+ gc.flags[FLG_COMMENTERROR] = TRUE;
+
/*
** Changed for version 2.4.
*/
flagcode modeflags[] =
{
FLG_ENUMINT, FLG_MACROMATCHNAME,
+ FLG_STRINGLITNOROOM,
FLG_MACROUNDEF, FLG_RELAXQUALS,
FLG_USEALLGLOBS, FLG_CHECKSTRICTGLOBALS,
FLG_CHECKSTRICTGLOBALIAS,
FLG_CHECKEDGLOBALIAS,
FLG_CHECKMODGLOBALIAS,
FLG_PREDBOOLOTHERS, FLG_PREDBOOLINT,
+ FLG_UNSIGNEDCOMPARE,
FLG_PARAMUNUSED, FLG_VARUNUSED, FLG_FUNCUNUSED,
FLG_TYPEUNUSED,
FLG_CONSTUNUSED, FLG_ENUMMEMUNUSED, FLG_FIELDUNUSED,
- FLG_PTRNUMCOMPARE, FLG_BOOLCOMPARE, FLG_MUTREP,
- FLG_NOEFFECT, FLG_IMPTYPE,
+ FLG_PTRNUMCOMPARE, FLG_BOOLCOMPARE, FLG_UNSIGNEDCOMPARE,
+ FLG_MUTREP, FLG_NOEFFECT, FLG_IMPTYPE,
FLG_RETVALOTHER, FLG_RETVALBOOL, FLG_RETVALINT,
- FLG_SPECUNDEF, FLG_INCONDEFS, FLG_INCONDEFSLIB,
+ FLG_SPECUNDEF, FLG_INCONDEFS, FLG_INCONDEFSLIB, FLG_MISPLACEDSHAREQUAL,
FLG_MATCHFIELDS,
+ FLG_FORMATCONST,
FLG_MACROPARAMS, FLG_MACROASSIGN, FLG_SEFPARAMS,
FLG_MACROSTMT, FLG_MACROPARENS,
FLG_MACROFCNDECL,
FLG_FIRSTCASE,
FLG_NESTEDEXTERN,
FLG_NUMLITERAL,
+ FLG_ZEROBOOL,
/* memchecks flags */
FLG_NULLDEREF,
FLG_NULLSTATE, FLG_NULLASSIGN,
FLG_COMPDESTROY, FLG_MUSTNOTALIAS,
FLG_MEMIMPLICIT,
FLG_BRANCHSTATE,
-
+ FLG_STATETRANSFER, FLG_STATEMERGE,
FLG_EVALORDER, FLG_SHADOW, FLG_READONLYSTRINGS,
FLG_EXITARG,
FLG_IMPCHECKEDSPECGLOBALS,
FLG_IFEMPTY, FLG_REALCOMPARE,
FLG_BOOLOPS, FLG_PTRNEGATE,
FLG_SHIFTSIGNED,
- INVALID_FLAG } ;
+ FLG_BUFFEROVERFLOWHIGH,
+ FLG_BUFFEROVERFLOW,
+ INVALID_FLAG
+ } ;
SETFLAGS ();
}
FLG_CHECKSTRICTGLOBALS, FLG_MACROMATCHNAME,
FLG_RETVALOTHER,
FLG_IFEMPTY,
+ FLG_BUFFEROVERFLOWHIGH,
FLG_RETSTACK, FLG_PTRNEGATE,
+ FLG_STATETRANSFER, FLG_STATEMERGE,
FLG_LONGUNSIGNEDINTEGRAL,
FLG_LONGUNSIGNEDUNSIGNEDINTEGRAL,
FLG_NUMLITERAL,
FLG_CHARINTLITERAL,
+ FLG_ZEROBOOL,
+ FLG_BUFFEROVERFLOWHIGH,
INVALID_FLAG
} ;
flagcode modeflags[] =
{
FLG_EXPORTLOCAL, FLG_IMPTYPE,
+ FLG_STATETRANSFER, FLG_STATEMERGE,
FLG_CHECKSTRICTGLOBALIAS,
FLG_CHECKEDGLOBALIAS,
FLG_CHECKMODGLOBALIAS,
FLG_UNCHECKEDGLOBALIAS,
+ FLG_FORMATCONST,
+ FLG_STRINGLITNOROOM,
+ FLG_STRINGLITSMALLER,
FLG_EXITARG, FLG_PTRNUMCOMPARE,
- FLG_BOOLCOMPARE, FLG_MACROUNDEF,
- FLG_MUSTMOD, FLG_ALLGLOBALS,
+ FLG_BOOLCOMPARE, FLG_UNSIGNEDCOMPARE,
+ FLG_MACROUNDEF, FLG_MUSTMOD, FLG_ALLGLOBALS,
FLG_PREDBOOLOTHERS, FLG_PREDBOOLPTR, FLG_PREDBOOLINT,
FLG_USEALLGLOBS, FLG_MUTREP, FLG_RETALIAS,
FLG_RETEXPOSE, FLG_ASSIGNEXPOSE, FLG_CASTEXPOSE,
FLG_RETVALOTHER, FLG_RETVALBOOL, FLG_RETVALINT,
FLG_SPECUNDEF, FLG_IMPCHECKMODINTERNALS,
FLG_DECLUNDEF, FLG_INCONDEFS, FLG_INCONDEFSLIB,
+ FLG_MISPLACEDSHAREQUAL, FLG_REDUNDANTSHAREQUAL,
FLG_MATCHFIELDS,
FLG_MACROPARAMS,
FLG_MACROASSIGN,
FLG_NESTEDEXTERN,
+ /* warn use flags */
+ FLG_MULTITHREADED, FLG_PORTABILITY, FLG_SUPERUSER, FLG_IMPLEMENTATIONOPTIONAL,
+ FLG_BUFFEROVERFLOWHIGH,
+
/* memchecks flags */
FLG_NULLSTATE, FLG_NULLDEREF, FLG_NULLASSIGN,
FLG_INCLUDENEST, FLG_ANSIRESERVED, FLG_CPPNAMES,
FLG_NOPARAMS, FLG_IFEMPTY, FLG_WHILEEMPTY, FLG_REALCOMPARE,
FLG_BOOLOPS, FLG_SHIFTSIGNED,
+ FLG_BUFFEROVERFLOWHIGH, FLG_BUFFEROVERFLOW,
INVALID_FLAG } ;
SETFLAGS ();
FLG_UNCHECKEDGLOBALIAS,
FLG_MODFILESYSTEM,
FLG_MACROMATCHNAME,
+ FLG_FORMATCONST,
+ FLG_STRINGLITNOROOM,
+ FLG_STRINGLITSMALLER,
+ FLG_STATETRANSFER, FLG_STATEMERGE,
FLG_MACROUNDEF, FLG_MUTREP, FLG_MUSTMOD,
FLG_ALLGLOBALS, FLG_IMPTYPE,
FLG_MODNOMODS, FLG_MODGLOBSUNSPEC, FLG_MODSTRICTGLOBSUNSPEC,
FLG_VARUNUSED,
FLG_NULLPOINTERARITH, FLG_POINTERARITH,
FLG_PTRNUMCOMPARE,
- FLG_BOOLCOMPARE, FLG_NOEFFECT,
- FLG_RETVALINT, FLG_RETVALBOOL, FLG_RETVALOTHER,
+ FLG_BOOLCOMPARE, FLG_UNSIGNEDCOMPARE,
+ FLG_NOEFFECT, FLG_RETVALINT, FLG_RETVALBOOL, FLG_RETVALOTHER,
FLG_ANSIRESERVED, FLG_ANSIRESERVEDLOCAL, FLG_CPPNAMES,
FLG_RETVALBOOL, FLG_RETVALINT, FLG_SPECUNDEF,
FLG_DECLUNDEF, FLG_STRICTOPS, FLG_INCONDEFS,
+ FLG_MISPLACEDSHAREQUAL, FLG_REDUNDANTSHAREQUAL,
FLG_INCONDEFSLIB, FLG_MATCHFIELDS, FLG_EXPORTMACRO, FLG_EXPORTVAR,
FLG_EXPORTFCN, FLG_EXPORTTYPE, FLG_EXPORTLOCAL, FLG_MACROPARAMS,
FLG_MACROASSIGN,
FLG_NESTEDEXTERN,
FLG_FIRSTCASE,
+ /* warn use flags */
+ FLG_MULTITHREADED, FLG_PORTABILITY, FLG_SUPERUSER, FLG_IMPLEMENTATIONOPTIONAL,
+ FLG_BUFFEROVERFLOWHIGH,
+ FLG_BUFFEROVERFLOW, FLG_TOCTOU,
+
/* memchecks flags */
FLG_NULLSTATE, FLG_NULLDEREF, FLG_NULLASSIGN,
FLG_NULLPASS, FLG_NULLRET,
FLG_SYSTEMDIRERRORS, FLG_UNUSEDSPECIAL,
FLG_SHIFTSIGNED, FLG_BITWISEOPS,
- INVALID_FLAG } ;
+ FLG_BUFFEROVERFLOWHIGH, FLG_BUFFEROVERFLOW,
+ INVALID_FLAG
+ } ;
SETFLAGS ();
}
bool
context_isSpecialFile (cstring fname)
{
- char *ext = filenameExtension (cstring_toCharsSafe (fname));
+ cstring ext = fileLib_getExtension (fname);
- return (mstring_equal (ext, ".y")
- || mstring_equal (ext, ".l")
+ return (cstring_equalLit (ext, ".y")
+ || cstring_equalLit (ext, ".l")
|| cstring_equalLit (fname, "lex.yy.c"));
}
bool
context_isSystemDir (cstring dir)
{
- cstring sysDirs = context_exposeString (FLG_SYSTEMDIRS);
- char *thisdir = cstring_toCharsSafe (sysDirs);
- char *nextdir = strchr (thisdir, SEPCHAR);
-
- if (nextdir != NULL)
+ cstring thisdir = cstring_copy (context_getString (FLG_SYSTEMDIRS));
+ cstring savedir = thisdir;
+ cstring nextdir = cstring_afterChar (thisdir, PATH_SEPARATOR);
+
+ if (cstring_isDefined (nextdir))
{
- *nextdir = '\0';
+ /*@access cstring@*/
+ *nextdir = '\0'; /* closes thisdir */
nextdir += 1;
+ /*@noaccess cstring@*/
}
- while (thisdir != NULL)
+ /* 2001-09-09: added thisdir[0] != '\0'
+ ** herbert: don't compare with an empty name!
+ ** should return false for empty directory path
+ */
+
+ while (!cstring_isEmpty (thisdir))
{
DPRINTF (("Test: %s / %s", dir, thisdir));
- if (cstring_equalCanonicalPrefix (dir, thisdir))
+ if (osd_equalCanonicalPrefix (dir, thisdir))
{
- if (nextdir != NULL)
- {
- *(nextdir - 1) = SEPCHAR;
- }
-
+ cstring_free (savedir);
return TRUE;
}
- if (nextdir != NULL)
- {
- *(nextdir - 1) = SEPCHAR;
- }
-
- if (nextdir != NULL)
+ if (cstring_isDefined (nextdir))
{
thisdir = nextdir;
- nextdir = strchr (thisdir, SEPCHAR);
+ nextdir = cstring_afterChar (thisdir, PATH_SEPARATOR);
- if (nextdir != NULL)
+ if (cstring_isDefined (nextdir))
{
+ /*@access cstring@*/
*nextdir = '\0';
nextdir += 1;
+ /*@noaccess cstring@*/
}
}
else
}
DPRINTF (("Returns FALSE"));
+ cstring_free (savedir);
return FALSE;
}
{
cstring base;
- if (gc.kind == CX_FUNCTION || gc.kind == CX_MACROFCN
- || gc.kind == CX_UNKNOWNMACRO)
+ if (context_inFunctionLike ())
{
gc.acct = typeIdSet_insert (gc.acct, t);
}
-
- gc.facct = typeIdSet_insert (gc.facct, t);
-
- base = fileloc_getBase (g_currentloc);
+
+ gc.facct = typeIdSet_insert (gc.facct, t);
+
+ base = fileloc_getBase (g_currentloc);
insertModuleAccess (base, t);
-
- }
+ DPRINTF (("Add file access: %s / %s", typeIdSet_unparse (gc.facct),
+ typeIdSet_unparse (gc.acct)));
+}
void
context_removeFileAccessType (typeId t)
gc.nacct = typeIdSet_insert (gc.nacct, t);
}
-void context_enterFunctionDecl (void)
+void context_enterFunctionHeader (void)
{
- llassert (gc.kind == CX_GLOBAL);
- gc.kind = CX_FCNDECL;
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Enter function header: %q", context_unparse ()));
+ }
+
+ if (gc.kind != CX_GLOBAL)
+ {
+ llparseerror (cstring_makeLiteral
+ ("Likely parse error. Function header outside global context."));
+ }
+ else
+ {
+ llassert (gc.kind == CX_GLOBAL);
+ DPRINTF (("Enter function header!"));
+ gc.inFunctionHeader = TRUE;
+ }
}
-void context_exitFunctionDecl (void)
+void context_exitFunctionHeader (void)
{
- gc.kind = CX_GLOBAL;
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Exit function header: %q", context_unparse ()));
+ }
+
+ DPRINTF (("Exit function header!"));
+ gc.inFunctionHeader = FALSE;
}
-bool context_inFunctionDecl (void)
+bool context_inFunctionHeader (void)
{
- return (gc.kind == CX_FCNDECL);
+ return (gc.inFunctionHeader);
}
+void context_enterFunctionDeclaration (uentry e)
+{
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Enter function declaration: %q", context_unparse ()));
+ }
+
+ DPRINTF (("Enter function decl"));
+ llassert (gc.savekind == CX_ERROR);
+ gc.savekind = gc.kind;
+ gc.savecont = gc.cont;
+ gc.kind = CX_FCNDECLARATION;
+ gc.cont.fcn = e;
+}
+
+void context_exitFunctionDeclaration (void)
+{
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Exit function declaration: %q", context_unparse ()));
+ }
+
+ DPRINTF (("Exit function decl"));
+ llassert (gc.savekind != CX_ERROR);
+ llassert (gc.kind == CX_FCNDECLARATION);
+ gc.kind = gc.savekind;
+ gc.cont = gc.savecont;
+
+ gc.savekind = CX_ERROR;
+
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("After exit function declaration: %q", context_unparse ()));
+ }
+}
+
+bool context_inFunctionDeclaration (void)
+{
+ return (gc.kind == CX_FCNDECLARATION);
+}
+
+
void
context_enterMacro (/*@observer@*/ uentry e)
{
gc.kind = CX_FUNCTION;
gc.cont.fcn = e;
+ DPRINTF (("Enter function: %s", uentry_unparse (e)));
+
if (uentry_hasAccessType (e))
{
gc.acct = typeIdSet_subtract (typeIdSet_union (gc.facct, uentry_accessType (e)),
{
gc.acct = gc.facct;
}
-
+
+ DPRINTF (("Enter function: %s / %s", uentry_unparse (e),
+ typeIdSet_unparse (gc.acct)));
+
gc.showfunction = context_getFlag (FLG_SHOWFUNC);
gc.globs = uentry_getGlobs (e);
sRef_enterFunctionScope ();
}
+void
+context_enterOldStyleScope (void)
+{
+ gc.kind = CX_OLDSTYLESCOPE;
+ DPRINTF (("Enter old style scope!"));
+ usymtab_enterFunctionScope (uentry_undefined);
+}
+
+void
+context_completeOldStyleFunction (uentry e)
+{
+ llassert (gc.kind == CX_OLDSTYLESCOPE);
+
+ gc.kind = CX_FUNCTION;
+ gc.cont.fcn = e;
+
+ DPRINTF (("Enter function: %s", uentry_unparse (e)));
+
+ if (uentry_hasAccessType (e))
+ {
+ gc.acct = typeIdSet_subtract (typeIdSet_union (gc.facct, uentry_accessType (e)),
+ gc.nacct);
+ }
+ else
+ {
+ gc.acct = gc.facct;
+ }
+
+ DPRINTF (("Enter function: %s / %s", uentry_unparse (e),
+ typeIdSet_unparse (gc.acct)));
+
+ gc.showfunction = context_getFlag (FLG_SHOWFUNC);
+
+ if (!globSet_isEmpty (uentry_getGlobs (e)))
+ {
+ llfatalerror (message ("%q: Old-style function declaration uses a clause (rewrite with function parameters): %q",
+ fileloc_unparse (g_currentloc), uentry_unparse (e)));
+ }
+
+ gc.showfunction = context_getFlag (FLG_SHOWFUNC);
+
+ gc.globs = uentry_getGlobs (e);
+ globSet_clear (gc.globs_used);
+
+ gc.mods = uentry_getMods (e);
+
+ if (!sRefSet_isEmpty (gc.mods))
+ {
+ llfatalerror (message ("%q: Old-style function declaration uses a clause (rewrite with function parameters): %q",
+ fileloc_unparse (g_currentloc), uentry_unparse (e)));
+ }
+
+ sRef_enterFunctionScope ();
+}
+
static bool context_checkStrictGlobals (void)
{
return (context_getFlag (FLG_CHECKSTRICTGLOBALS));
{
uentry ue = sRef_getUentry (el);
- /* no: llassert (sRef_isGlobal (el)); also check local statics */
+ /* no: llassert (sRef_isFileOrGlobalScope (el)); also check local statics */
if (uentry_isCheckedModify (ue)
|| (!uentry_isUnchecked (ue) && (gc.flags[FLG_ALLGLOBALS])))
}
void
-context_usedGlobal (sRef el)
+context_usedGlobal (/*@exposed@*/ sRef el)
{
if (!globSet_member (gc.globs_used, el))
{
bool
context_globAccess (sRef s)
{
- llassert (sRef_isGlobal (s) || sRef_isKindSpecial (s));
+ llassert (sRef_isFileOrGlobalScope (s) || sRef_isKindSpecial (s));
return (globSet_member (gc.globs, s));
}
{
if (context_inFunctionLike ())
{
+ DPRINTF (("Access %d / %s",
+ t, typeIdSet_unparse (gc.acct)));
return (typeIdSet_member (gc.acct, t));
}
else
return ctype_unknown;
}
- return (ctype_returnValue (f));
+ return (ctype_getReturnType (f));
}
bool
void
context_exitAllClauses (void)
-{
-
+{
while (!clauseStack_isEmpty (gc.clauses))
{
clause el = clauseStack_top (gc.clauses);
-
gc.inclause = el;
if (clause_isNone (el))
}
}
- clauseStack_clear (gc.clauses);
+ clauseStack_clear (gc.clauses);
+ gc.inclause = NOCLAUSE;
+}
-
+void
+context_exitAllClausesQuiet (void)
+{
+ while (!clauseStack_isEmpty (gc.clauses))
+ {
+ clause el = clauseStack_top (gc.clauses);
+ gc.inclause = el;
+
+ usymtab_quietExitScope (g_currentloc);
+ clauseStack_pop (gc.clauses);
+ }
+
+ clauseStack_clear (gc.clauses);
gc.inclause = NOCLAUSE;
}
void context_exitClauseAux (exprNode pred, exprNode tbranch)
{
context_setJustPopped ();
+ /*@i32 was makeAlt */
usymtab_popTrueBranch (pred, tbranch, gc.inclause);
clauseStack_pop (gc.clauses);
gc.inclause = topClause (gc.clauses);
void context_exitTrueClause (exprNode pred, exprNode tbranch)
{
+ DPRINTF (("Exit true clause: %s", exprNode_unparse (tbranch)));
+
if (gc.inclause != TRUECLAUSE)
{
llparseerror (cstring_makeLiteral
("Likely parse error. Conditional clauses are inconsistent."));
return;
}
-
-
- context_setJustPopped ();
-
+
+ context_setJustPopped ();
usymtab_popTrueBranch (pred, tbranch, TRUECLAUSE);
clauseStack_pop (gc.clauses);
- gc.inclause = topClause (gc.clauses);
-
- }
+ gc.inclause = topClause (gc.clauses);
+}
void context_exitIterClause (exprNode body)
{
DPRINTF (("Popping case clause: %s",
clauseStack_unparse (gc.clauses)));
-
+
if (gc.inclause == CASECLAUSE) {
context_exitCaseClause ();
}
if (context_getFlag (FLG_LOOPEXEC))
{
- usymtab_popTrueExecBranch (forPred, body, FORCLAUSE);
+ usymtab_popTrueExecBranch (forPred, body, FORCLAUSE);
}
else
{
{
context_exitClauseAux (exprNode_undefined, exprNode_undefined);
}
-
}
void context_exitClause (exprNode pred, exprNode tbranch, exprNode fbranch)
{
-
context_setJustPopped ();
-
+
if (gc.inclause == FALSECLAUSE)
{
usymtab_popBranches (pred, tbranch, fbranch, FALSE, FALSECLAUSE);
-
+
llassert (clauseStack_top (gc.clauses) == FALSECLAUSE);
clauseStack_pop (gc.clauses);
}
else
{
- context_exitTrueClause (pred, tbranch);
+ context_exitTrueClause (pred, tbranch);
}
}
void
context_returnFunction (void)
{
- usymtab_checkFinalScope (TRUE);
- }
+ usymtab_checkFinalScope (TRUE);
+}
void
context_exitFunction (void)
-{
-
+{
+ DPRINTF (("Exit function: %s", context_unparse ()));
+
if (!context_inFunction () && !context_inMacroConstant ()
- && !context_inMacroUnknown ()
+ && !context_inUnknownMacro ()
&& !context_inIterDef () && !context_inIterEnd ())
{
/*
** not a bug because of parse errors
*/
+
+ BADBRANCH;
}
else
{
}
}
+ DPRINTF (("Exit function: %s", uentry_unparse (gc.cont.fcn)));
+
/*
** clear file static modifies
*/
llassert (clauseStack_isEmpty (gc.clauses));
llassert (gc.inclause == NOCLAUSE);
+ DPRINTF (("After exit function: %s", context_unparse ()));
}
void
context_exitInnerPlain ();
}
- if (!context_inFunction () && !context_inMacroConstant () && !context_inMacroUnknown ()
+ if (!context_inFunction () && !context_inMacroConstant () && !context_inUnknownMacro ()
&& !context_inIterDef () && !context_inIterEnd ())
{
}
{
if (context_inFunctionLike ())
{
- return (uentry_getParams (gc.cont.fcn));
+ return (uentry_getParams (gc.cont.fcn));
}
else
{
addModuleAccess (cstring_makeLiteral ("types"), boolt);
}
+# if 0
bool
context_canAccessBool (void)
{
+ return TRUE;
+}
+# endif
+
+/*
static typeId boolType = typeId_invalid;
-
- if (context_getFlag (FLG_ABSTRACTBOOL))
+ if (typeId_isInvalid (boolType))
+ {
+ boolType = usymtab_getTypeId (context_getBoolName ());
+ }
+
+ if (typeId_isInvalid (boolType)) {
+ return FALSE;
+ } else {
+ return (typeIdSet_member (gc.acct, boolType));
+ }
+}
+*/
+
+/* evs 2000-07-25: old version - replaced */
+
+ctype
+context_boolImplementationType () {
+ /* For now, this is bogus! */
+ return ctype_int;
+}
+
+bool
+context_canAccessBool (void)
+{
+ static typeId boolType = typeId_invalid;
+
+ if (typeId_isInvalid (boolType))
+ {
+ boolType = usymtab_getTypeId (context_getBoolName ());
+ }
+
+ if (!typeId_isInvalid (boolType))
+ {
+ return context_hasAccess (boolType);
+ }
+ else
{
- if (typeId_isInvalid (boolType))
- {
- boolType = usymtab_getTypeId (context_getBoolName ());
- }
- return (typeIdSet_member (gc.acct, boolType));
+ ;
}
- return FALSE;
+ return FALSE;
}
void
void
context_recordFileModifies (sRefSet mods)
{
- gc.modrecs = sRefSetList_add (gc.modrecs, mods);
+ gc.modrecs = sRefSetList_add (gc.modrecs, mods);
}
void
context_recordFileGlobals (globSet mods)
{
- /*@access globSet@*/ context_recordFileModifies (mods); /*@noaccess globSet@*/
+ DPRINTF (("Recording file globals: %s", globSet_unparse (mods)));
+ /*@access globSet@*/ context_recordFileModifies (mods); /*@noaccess globSet@*/
}
void
llassert (index >= 0 && index <= NUMVALUEFLAGS);
- if (val <= 0)
+ switch (flag)
{
- switch (flag)
+ case FLG_LINELEN:
+ if (val <= 0)
{
- case FLG_INCLUDENEST:
- case FLG_CONTROLNESTDEPTH:
- case FLG_STRINGLITERALLEN:
- case FLG_NUMSTRUCTFIELDS:
- case FLG_NUMENUMMEMBERS:
- case FLG_LINELEN:
- {
- cstring warn = message ("Value for %s must be a positive "
+
+ llerror_flagWarning (message ("Value for %s must be a positive "
"number (given %d)",
- flagcode_unparse (flag), val);
-
- flagWarning (warn);
- cstring_free (warn);
- val = MINLINELEN;
- }
+ flagcode_unparse (flag), val));
return;
- default:
- break;
}
- }
+ if (flag == FLG_LINELEN && val < MINLINELEN)
+ {
+ llerror_flagWarning (message ("Value for %s must be at least %d (given %d)",
+ flagcode_unparse (flag),
+ MINLINELEN, val));
+ val = MINLINELEN;
+ }
+ break;
- if (flag == FLG_LINELEN && val < MINLINELEN)
- {
- cstring warn = message ("Value for %s must be at least %d (given %d)",
- flagcode_unparse (flag),
- MINLINELEN, val);
- flagWarning (warn);
- cstring_free (warn);
- val = MINLINELEN;
- }
+ case FLG_INCLUDENEST:
+ case FLG_CONTROLNESTDEPTH:
+ case FLG_STRINGLITERALLEN:
+ case FLG_NUMSTRUCTFIELDS:
+ case FLG_NUMENUMMEMBERS:
+ case FLG_INDENTSPACES:
+ if (val < 0)
+ {
+
+ llerror_flagWarning (message ("Value for %s must be a non-negative "
+ "number (given %d)",
+ flagcode_unparse (flag), val));
+ return;
+ }
- gc.values[index] = val;
+ break;
+ default:
+ break;
+ }
+
+ gc.values[index] = val;
}
void
if (cstring_getChar (tval, n) != '\"')
{
- cstring msg = message ("Setting -systemdirs to string with unmatching quotes: %s", val);
- flagWarning (msg);
- cstring_free (msg);
+ llerror_flagWarning (message ("Setting -systemdirs to string with unmatching quotes: %s", val));
}
else
{
}
if (cstring_length (val) >= 1
- && cstring_firstChar (val) == '"')
+ && cstring_firstChar (val) == '\"')
{
- cstring s = message
- ("setting %s to string beginning with \". You probably "
- "don't meant to have the \"'s.",
- flagcode_unparse (flag));
-
- flagWarning (s);
- cstring_free (s);
+ llerror_flagWarning (message
+ ("setting %s to string beginning with \". You probably "
+ "don't meant to have the \"'s.",
+ flagcode_unparse (flag)));
}
if (flag == FLG_BOOLTYPE)
/*@globals undef gc; @*/
{
gc.kind = CX_GLOBAL;
+
+ gc.savekind = CX_ERROR;
+ gc.savecont.glob = FALSE;
+
gc.instandardlib = FALSE;
gc.numerrors = 0;
gc.neednl = FALSE;
gc.mc = macrocache_create ();
gc.nmods = 0;
gc.maxmods = DEFAULTMAXMODS;
- gc.moduleaccess = (maccesst *)
- dmalloc (sizeof (*gc.moduleaccess) * (gc.maxmods));
-
+ gc.moduleaccess = (maccesst *) dmalloc (sizeof (*gc.moduleaccess) * (gc.maxmods));
+
gc.library = FLG_ANSILIB;
gc.locstack = filelocStack_new ();
usymtab_initMod ();
context_resetAllFlags ();
+ assertSet (gc.flags); /* Can't use global in defines */
+ assertSet (gc.saveflags);
+ assertSet (gc.values);
+ assertSet (gc.strings);
+
conext_resetAllCounters ();
+ assertSet (gc.counters);
+
context_setMode (DEFAULT_MODE);
+
+ gc.stateTable = metaStateTable_create ();
+ gc.annotTable = annotationTable_create ();
+
+ gc.inFunctionHeader = FALSE;
+
+ DPRINTF (("Annotations: \n%s",
+ cstring_toCharsSafe (annotationTable_unparse (gc.annotTable))));
+ DPRINTF (("State: \n%s",
+ cstring_toCharsSafe (metaStateTable_unparse (gc.stateTable))));
+
}
ctype
ct = ctype_makeConj (ct, ctype_voidPointer);
}
- if (!context_getFlag (FLG_ABSTRACTBOOL))
- {
- ct = ctype_makeConj (ct, ctype_bool);
- }
+ if (context_getFlag (FLG_ZEROBOOL)) {
+ ct = ctype_makeConj (ct, ctype_bool);
+ }
return ct;
}
s = message ("Global Context:%q", fileloc_unparse (g_currentloc));
break;
case CX_INNER:
- s = message ("Inner Context:%q", fileloc_unparse (g_currentloc));
+ s = message ("Inner Context [%d] : %q",
+ gc.cont.cdepth,
+ fileloc_unparse (g_currentloc));
break;
case CX_FUNCTION:
s = message ("Function %q :%q \n\taccess %q\n\tmodifies %q",
case CX_ITEREND:
s = message ("Iter end %q", uentry_unparse (gc.cont.fcn));
break;
+ case CX_FCNDECLARATION:
+ s = message ("Function declaration %q", uentry_unparse (gc.cont.fcn));
+ break;
default:
s = message ("Un-unparseable context: %d", (int) gc.kind);
break;
void
context_enterInnerContext (void)
{
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Enter inner context: %q", context_unparse ()));
+ }
+
if (gc.kind == CX_GLOBAL)
{
gc.kind = CX_INNER;
;
}
-
usymtab_enterScope ();
pushClause (NOCLAUSE);
}
void
context_exitInner (exprNode exp)
{
-
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Enter inner context: %q", context_unparse ()));
+ }
+
llassertprint (gc.inclause == NOCLAUSE || gc.inclause == CASECLAUSE,
("inclause = %s", clause_nameTaken (gc.inclause)));
void
context_enterStructInnerContext (void)
{
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Enter struct inner context: %q", context_unparse ()));
+ }
+
if (gc.kind == CX_GLOBAL)
{
gc.kind = CX_INNER;
}
usymtab_enterScope ();
+
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Enter struct inner context: %q", context_unparse ()));
+ }
}
void
context_exitStructInnerContext (void)
{
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Exit struct inner context: %q [%d]", context_unparse (), gc.cont.cdepth));
+ }
+
if (gc.kind == CX_INNER)
{
- if (--gc.cont.cdepth == 0)
+ if (gc.cont.cdepth <= 0)
{
+ llcontbuglit ("Attempt to exit inner context with no depth");
gc.kind = CX_GLOBAL;
gc.cont.glob = TRUE;
+ gc.cont.cdepth = 0;
}
- }
+ else {
+ gc.cont.cdepth--;
+
+ if (gc.cont.cdepth == 0)
+ {
+ gc.kind = CX_GLOBAL;
+ gc.cont.glob = TRUE;
+ }
+ }
+ }
else
{
if (gc.kind == CX_GLOBAL)
}
usymtab_exitScope (exprNode_undefined);
+
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("After exit struct inner context: %q [%d]", context_unparse (), gc.cont.cdepth));
+ }
}
void
context_exitInnerSafe (void)
{
-
+ if (context_getFlag (FLG_GRAMMAR))
+ {
+ lldiagmsg (message ("Exit inner safe: %q", context_unparse ()));
+ }
+
if (gc.kind == CX_INNER)
{
- if (--gc.cont.cdepth == 0)
+ if (--gc.cont.cdepth <= 0)
{
- gc.cont.cdepth++;
+ gc.cont.cdepth = 0;
}
}
else if (gc.kind == CX_GLOBAL)
{
cstring baseName = fileloc_getBase (g_currentloc);
- DPRINTF (("Access: %s", baseName));
-
if (context_getFlag (FLG_ACCESSFILE))
{
if (usymtab_existsType (baseName))
gc.facct = typeIdSet_insert (gc.facct,
usymtab_getTypeId (baseName));
}
+ else
+ {
+ ;
+ }
}
if (context_getFlag (FLG_ACCESSMODULE))
gc.acct = gc.facct;
gc.inheader = FALSE;
}
-
+
/* 17 Jan 1995: forgot to clear nacct */
- gc.nacct = typeIdSet_emptySet ();
- }
+ gc.nacct = typeIdSet_emptySet ();
+}
static void
context_enterFileAux (void)
context_inFunctionLike (void)
{
return (gc.kind == CX_FUNCTION || gc.kind == CX_MACROFCN
+ || gc.kind == CX_FCNDECLARATION
|| gc.kind == CX_UNKNOWNMACRO || gc.kind == CX_ITERDEF);
}
if (fileId_isValid (currentFile ()))
{
fileloc lastfl;
- cstring cbase = cstring_fromChars
- (removePathFree
- (removeAnyExtension
- (cstring_toCharsSafe (fileName (currentFile ())))));
+ cstring cbase = fileLib_removePathFree (fileLib_removeAnyExtension (fileName (currentFile ())));
gc.inmacrocache = TRUE;
-
- lastfl = macrocache_processFileElements (gc.mc, cbase);
+
+ DPRINTF (("Processing macros: %s", cbase));
+ lastfl = macrocache_processFileElements (gc.mc, cbase);
+ DPRINTF (("Processing macros: %s", fileloc_unparse (lastfl)));
+
cstring_free (cbase);
if (fileloc_isDefined (lastfl))
}
void
-context_exitFile (void)
+context_exitCFile (void)
{
if (gc.kind != CX_GLOBAL)
{
sRefSetList_elements (gc.modrecs, mods)
{
sRefSet_clearStatics (mods);
- } end_sRefSetList_elements ;
+ } end_sRefSetList_elements ;
sRefSetList_clear (gc.modrecs);
-
+
context_processMacros ();
cleanupMessages ();
-
+
usymtab_exitFile ();
-
+
gc.inDerivedFile = FALSE;
filelocStack_clear (gc.locstack);
-
+
gc.nacct = typeIdSet_emptySet (); /* empty noaccess */
-
+
gc.cont.glob = TRUE;
if (gc.savedFlags)
context_restoreFlagSettings ();
gc.savedFlags = FALSE;
}
+
+ /*
+ DPRINTF (("After exiting file: "));
+ usymtab_printAll ();
+ */
}
void
{
if (gc.kind != CX_GLOBAL)
{
- if (context_inMacro ()) /* this is okay, file could end without newline in macro */
+ if (context_inMacro ())
+ /* this is okay, file could end without newline in macro */
{
+ DPRINTF (("Still in macro: %s",
+ context_unparse ()));
context_exitFunction ();
}
else
context_saveLocation (void)
{
/* was llassert (fileloc_isUndefined (gc.saveloc)) */
- fileloc_free (gc.saveloc);
-
-
+ fileloc_free (gc.saveloc);
gc.saveloc = fileloc_copy (g_currentloc);
- }
+}
fileloc
context_getSaveLocation (void)
{
fileloc fl = gc.saveloc;
-
- gc.saveloc = fileloc_undefined;
+ gc.saveloc = fileloc_undefined;
return fl;
}
void
context_userSetFlag (flagcode f, bool b)
{
- DPRINTF (("set flag: %s", flagcode_name (f)));
+ DPRINTF (("set flag: %s", flagcode_unparse (f)));
if (f == FLG_NEVERINCLUDE && b)
{
if (gc.flags[FLG_EXPORTHEADER])
{
- flagWarning (cstring_makeLiteralTemp
- ("setting +neverinclude after +exportheader. "
- "Turning off exportheader, since headers are not checked "
- "when +neverinclude is used."));
+ llerror_flagWarning (cstring_makeLiteral
+ ("setting +neverinclude after +exportheader. "
+ "Turning off exportheader, since headers are not checked "
+ "when +neverinclude is used."));
gc.flags[FLG_EXPORTHEADER] = FALSE;
}
{
if (gc.flags[FLG_NEVERINCLUDE])
{
- flagWarning (cstring_makeLiteralTemp
- ("setting +exportheader after +neverinclude. "
- "Not setting exportheader, since headers are not checked "
- "when +neverinclude is used."));
+ llerror_flagWarning (cstring_makeLiteral
+ ("setting +exportheader after +neverinclude. "
+ "Not setting exportheader, since headers are not checked "
+ "when +neverinclude is used."));
gc.flags[FLG_EXPORTHEADER] = FALSE;
return;
}
&& !flagcode_isIdemFlag (f)
&& !flagcode_hasArgument (f))
{
- cstring warn = message ("setting %s%s redundant with current value",
- cstring_makeLiteralTemp (b ? "+" : "-"),
- flagcode_name (f));
- flagWarning (warn);
- cstring_free (warn);
+ llerror_flagWarning (message ("setting %s%s redundant with current value",
+ cstring_makeLiteralTemp (b ? "+" : "-"),
+ flagcode_unparse (f)));
}
}
+ if (flagcode_isWarnUseFlag (f) && b)
+ {
+ if (!context_getFlag (FLG_WARNUSE))
+ {
+ llerror_flagWarning (message ("flag +%s is canceled by -warnuse",
+ flagcode_unparse (f)));
+
+ }
+ }
+
+
if (flagcode_isLibraryFlag (f))
{
if (gc.library != FLG_ANSILIB
&& gc.library != f)
{
- cstring warn = message ("selecting library %s after library %s was "
- "selected (only one library may be used)",
- flagcode_name (f),
- flagcode_name (gc.library));
- flagWarning (warn);
- cstring_free (warn);
+ llerror_flagWarning (message ("selecting library %s after library %s was "
+ "selected (only one library may be used)",
+ flagcode_unparse (f),
+ flagcode_unparse (gc.library)));
}
if (f == FLG_UNIXLIB)
{
if (context_getFlag (FLG_WARNUNIXLIB))
{
- flagWarning (cstring_makeLiteralTemp
- ("selecting unix library. Unix library is "
- "ad hoc addition to POSIX library. Recommend "
- "use +posixlib to select POSIX library instead. "
- "Use -warnunixlib to suppress this message."));
+ llerror_flagWarning (cstring_makeLiteral
+ ("selecting unix library. Unix library is "
+ "ad hoc addition to POSIX library. Recommend "
+ "use +posixlib to select POSIX library instead. "
+ "Use -warnunixlib to suppress this message."));
}
}
gc.library = f;
}
-
- gc.setGlobally[f] = TRUE;
+
+ if (flagcode_isNameChecksFlag (f) && b && !context_maybeSet (FLG_NAMECHECKS))
+ {
+ llerror_flagWarning (message
+ ("setting +%s will not produce warnings with -namechecks. Must set +namechecks also.",
+ flagcode_unparse (f)));
+ }
+
+ gc.setGlobally[f] = TRUE;
context_setFlag (f, b);
}
# define DOSET(ff,b) \
do { if (inFile) { gc.setLocally[ff] = TRUE; \
context_addFlagMarker (ff, ynm_fromBool (b)); } \
- DPRINTF (("set flag: %s / %s", flagcode_name (ff), bool_unparse (b))); \
+ DPRINTF (("set flag: %s / %s", flagcode_unparse (ff), bool_unparse (b))); \
gc.flags[ff] = b; } while (FALSE)
static void
}
}
- if (flagcode_isSpecialFlag (f))
- {
- gc.flags[f] = b;
-
-
- switch (f)
- {
- case FLG_ALLEMPTY:
- DOSET (FLG_ALLEMPTY, b);
- DOSET (FLG_IFEMPTY, b);
- DOSET (FLG_WHILEEMPTY, b);
- DOSET (FLG_FOREMPTY, b);
- break;
- case FLG_PREDBOOL:
- DOSET (FLG_PREDBOOL, b);
- DOSET (FLG_PREDBOOLINT, b);
- DOSET (FLG_PREDBOOLPTR, b);
- DOSET (FLG_PREDBOOLOTHERS, b);
- break;
- case FLG_GLOBALIAS:
- DOSET (FLG_CHECKSTRICTGLOBALIAS, b);
- DOSET (FLG_CHECKEDGLOBALIAS, b);
- DOSET (FLG_CHECKMODGLOBALIAS, b);
- DOSET (FLG_UNCHECKEDGLOBALIAS, b);
- break;
- case FLG_ALLBLOCK:
- DOSET (FLG_ALLBLOCK, b);
- DOSET (FLG_IFBLOCK, b);
- DOSET (FLG_WHILEBLOCK, b);
- DOSET (FLG_FORBLOCK, b);
- break;
- case FLG_GRAMMAR:
- if (b)
- {
- yydebug = 1;
- }
- else
- {
- yydebug = 0;
- }
-
- DOSET (FLG_GRAMMAR, b);
- break;
- case FLG_CODEIMPONLY:
- DOSET (FLG_CODEIMPONLY, b);
- DOSET (FLG_GLOBIMPONLY, b);
- DOSET (FLG_RETIMPONLY, b);
- DOSET (FLG_STRUCTIMPONLY, b);
- break;
- case FLG_SPECALLIMPONLY:
- DOSET (FLG_SPECALLIMPONLY, b);
- DOSET (FLG_SPECGLOBIMPONLY, b);
- DOSET (FLG_SPECRETIMPONLY, b);
- DOSET (FLG_SPECSTRUCTIMPONLY, b);
- break;
- case FLG_ALLIMPONLY:
- DOSET (FLG_ALLIMPONLY, b);
- DOSET (FLG_GLOBIMPONLY, b);
- DOSET (FLG_RETIMPONLY, b);
- DOSET (FLG_STRUCTIMPONLY, b);
- DOSET (FLG_SPECGLOBIMPONLY, b);
- DOSET (FLG_SPECRETIMPONLY, b);
- DOSET (FLG_SPECSTRUCTIMPONLY, b);
- break;
- case FLG_ANSILIMITS:
- DOSET (FLG_ANSILIMITS, b);
- DOSET (FLG_CONTROLNESTDEPTH, b);
- DOSET (FLG_STRINGLITERALLEN, b);
- DOSET (FLG_INCLUDENEST, b);
- DOSET (FLG_NUMSTRUCTFIELDS, b);
- DOSET (FLG_NUMENUMMEMBERS, b);
-
- if (b)
- {
- context_setValue (FLG_CONTROLNESTDEPTH, DEFAULT_CONTROLNESTDEPTH);
- context_setValue (FLG_STRINGLITERALLEN, DEFAULT_STRINGLITERALLEN);
- context_setValue (FLG_INCLUDENEST, DEFAULT_INCLUDENEST);
- context_setValue (FLG_NUMSTRUCTFIELDS, DEFAULT_NUMSTRUCTFIELDS);
- context_setValue (FLG_NUMENUMMEMBERS, DEFAULT_NUMENUMMEMBERS);
- }
- break;
- case FLG_EXTERNALNAMELEN:
- DOSET (FLG_DISTINCTEXTERNALNAMES, TRUE);
- DOSET (FLG_EXTERNALNAMELEN, TRUE);
- break;
- case FLG_INTERNALNAMELEN:
- DOSET (FLG_DISTINCTINTERNALNAMES, TRUE);
- DOSET (FLG_INTERNALNAMELEN, TRUE);
- break;
- case FLG_EXTERNALNAMECASEINSENSITIVE:
- DOSET (FLG_EXTERNALNAMECASEINSENSITIVE, b);
-
- if (b && !gc.flags[FLG_DISTINCTEXTERNALNAMES])
- {
- DOSET (FLG_DISTINCTEXTERNALNAMES, TRUE);
- context_setValue (FLG_EXTERNALNAMELEN, 0);
- }
- break;
- case FLG_INTERNALNAMECASEINSENSITIVE:
- DOSET (FLG_INTERNALNAMECASEINSENSITIVE, b);
+ /*
+ ** Removed test for special flags.
+ */
- if (b && !gc.flags[FLG_DISTINCTINTERNALNAMES])
- {
- DOSET (FLG_DISTINCTINTERNALNAMES, TRUE);
- context_setValue (FLG_INTERNALNAMELEN, 0);
- }
- break;
- case FLG_INTERNALNAMELOOKALIKE:
- DOSET (FLG_INTERNALNAMELOOKALIKE, b);
+ if (flagcode_isIdemFlag (f))
+ {
+ DOSET (f, TRUE);
+ }
+ else
+ {
+ DOSET (f, b);
+ }
- if (b && !gc.flags[FLG_DISTINCTINTERNALNAMES])
+ if (f >= FLG_ITS4MOSTRISKY && f <= FLG_ITS4LOWRISK)
+ {
+ if (b) /* Turing higher level on, turns on all lower levels */
+ {
+ switch (f)
{
- DOSET (FLG_DISTINCTINTERNALNAMES, TRUE);
- context_setValue (FLG_INTERNALNAMELEN, 0);
+ case FLG_ITS4MOSTRISKY:
+ DOSET (FLG_ITS4VERYRISKY, b);
+ /*@fallthrough@*/
+ case FLG_ITS4VERYRISKY:
+ DOSET (FLG_ITS4RISKY, b);
+ /*@fallthrough@*/
+ case FLG_ITS4RISKY:
+ DOSET (FLG_ITS4MODERATERISK, b);
+ /*@fallthrough@*/
+ case FLG_ITS4MODERATERISK:
+ DOSET (FLG_ITS4LOWRISK, b);
+ /*@fallthrough@*/
+ case FLG_ITS4LOWRISK:
+ break;
+ BADDEFAULT;
}
- break;
- case FLG_MODUNSPEC:
- DOSET (FLG_MODNOMODS, b);
- DOSET (FLG_MODGLOBSUNSPEC, b);
- DOSET (FLG_MODSTRICTGLOBSUNSPEC, b);
- break;
- case FLG_EXPORTANY:
- DOSET (FLG_EXPORTVAR, b);
- DOSET (FLG_EXPORTFCN, b);
- DOSET (FLG_EXPORTTYPE, b);
- DOSET (FLG_EXPORTMACRO, b);
- DOSET (FLG_EXPORTCONST, b);
- gc.anyExports = TRUE;
- break;
- case FLG_REPEXPOSE:
- DOSET (FLG_RETEXPOSE, b);
- DOSET (FLG_ASSIGNEXPOSE, b);
- DOSET (FLG_CASTEXPOSE, b);
- break;
- case FLG_RETVAL:
- DOSET (FLG_RETVALBOOL, b);
- DOSET (FLG_RETVALINT, b);
- DOSET (FLG_RETVALOTHER, b);
- break;
- case FLG_PARTIAL:
- if (b)
+ }
+ else /* Turning level off, turns off all higher levels */
+ {
+ switch (f)
{
- DOSET (FLG_EXPORTLOCAL, FALSE);
- DOSET (FLG_DECLUNDEF, FALSE);
- DOSET (FLG_SPECUNDEF, FALSE);
- DOSET (FLG_TOPUNUSED, FALSE);
+ case FLG_ITS4LOWRISK:
+ DOSET (FLG_ITS4MODERATERISK, b);
+ /*@fallthrough@*/
+ case FLG_ITS4MODERATERISK:
+ DOSET (FLG_ITS4RISKY, b);
+ /*@fallthrough@*/
+ case FLG_ITS4RISKY:
+ DOSET (FLG_ITS4VERYRISKY, b);
+ /*@fallthrough@*/
+ case FLG_ITS4VERYRISKY:
+ DOSET (FLG_ITS4MOSTRISKY, b);
+ /*@fallthrough@*/
+ case FLG_ITS4MOSTRISKY:
+ break;
+ BADDEFAULT;
}
- break;
- case FLG_DEEPBREAK:
- DOSET (FLG_LOOPLOOPBREAK, b);
- DOSET (FLG_LOOPSWITCHBREAK, b);
- DOSET (FLG_SWITCHLOOPBREAK, b);
- DOSET (FLG_SWITCHSWITCHBREAK, b);
- DOSET (FLG_LOOPLOOPCONTINUE, b);
- DOSET (FLG_DEEPBREAK, b);
- break;
- case FLG_ACCESSALL:
- DOSET (FLG_ACCESSMODULE, b);
- DOSET (FLG_ACCESSFILE, b);
- DOSET (FLG_ACCESSCZECH, b);
- break;
- case FLG_ALLMACROS:
- DOSET (FLG_ALLMACROS, b);
- DOSET (FLG_FCNMACROS, b);
- DOSET (FLG_CONSTMACROS, b);
- break;
- case FLG_CZECH:
- if (b) { DOSET (FLG_ACCESSCZECH, b); }
- DOSET (FLG_CZECHFUNCTIONS, b);
- DOSET (FLG_CZECHVARS, b);
- DOSET (FLG_CZECHCONSTANTS, b);
- DOSET (FLG_CZECHTYPES, b);
- break;
- case FLG_SLOVAK:
- if (b) { DOSET (FLG_ACCESSSLOVAK, b); }
- DOSET (FLG_SLOVAKFUNCTIONS, b);
- DOSET (FLG_SLOVAKVARS, b);
- DOSET (FLG_SLOVAKCONSTANTS, b);
- DOSET (FLG_SLOVAKTYPES, b);
- break;
- case FLG_CZECHOSLOVAK:
- if (b) { DOSET (FLG_ACCESSCZECHOSLOVAK, b); }
- DOSET (FLG_CZECHOSLOVAKFUNCTIONS, b);
- DOSET (FLG_CZECHOSLOVAKVARS, b);
- DOSET (FLG_CZECHOSLOVAKCONSTANTS, b);
- DOSET (FLG_CZECHOSLOVAKTYPES, b);
- break;
- case FLG_NULL:
- DOSET (FLG_NULLSTATE, b);
- DOSET (FLG_NULLDEREF, b);
- DOSET (FLG_NULLASSIGN, b);
- DOSET (FLG_NULLPASS, b);
- DOSET (FLG_NULLRET, b);
- break;
- case FLG_MEMCHECKS:
- DOSET (FLG_NULLSTATE, b);
- DOSET (FLG_NULLDEREF, b);
- DOSET (FLG_NULLASSIGN, b);
- DOSET (FLG_NULLPASS, b);
- DOSET (FLG_NULLRET, b);
- DOSET (FLG_COMPDEF, b);
- DOSET (FLG_COMPMEMPASS, b);
- DOSET (FLG_UNIONDEF, b);
- DOSET (FLG_MEMTRANS, b);
- DOSET (FLG_USERELEASED, b);
- DOSET (FLG_ALIASUNIQUE, b);
- DOSET (FLG_MAYALIASUNIQUE, b);
- DOSET (FLG_MUSTFREE, b);
- DOSET (FLG_MUSTDEFINE, b);
- DOSET (FLG_GLOBSTATE, b);
- DOSET (FLG_COMPDESTROY, b);
- DOSET (FLG_MUSTNOTALIAS, b);
- DOSET (FLG_MEMIMPLICIT, b);
- DOSET (FLG_BRANCHSTATE, b);
- /*@fallthrough@*/ /* also sets memtrans flags */
- case FLG_MEMTRANS:
- DOSET (FLG_MEMTRANS, b);
- DOSET (FLG_EXPOSETRANS, b);
- DOSET (FLG_OBSERVERTRANS, b);
- DOSET (FLG_DEPENDENTTRANS, b);
- DOSET (FLG_NEWREFTRANS, b);
- DOSET (FLG_ONLYTRANS, b);
- DOSET (FLG_OWNEDTRANS, b);
- DOSET (FLG_FRESHTRANS, b);
- DOSET (FLG_SHAREDTRANS, b);
- DOSET (FLG_TEMPTRANS, b);
- DOSET (FLG_KEPTTRANS, b);
- DOSET (FLG_REFCOUNTTRANS, b);
- DOSET (FLG_STATICTRANS, b);
- DOSET (FLG_UNKNOWNTRANS, b);
- DOSET (FLG_KEEPTRANS, b);
- DOSET (FLG_IMMEDIATETRANS, b);
- break;
-
- default:
- llcontbug (message ("Unhandled special flag: %s",
- flagcode_unparse (f)));
- break;
}
}
- else
- {
- if (flagcode_isIdemFlag (f))
+
+ switch (f)
+ {
+ case FLG_ALLEMPTY:
+ DOSET (FLG_ALLEMPTY, b);
+ DOSET (FLG_IFEMPTY, b);
+ DOSET (FLG_WHILEEMPTY, b);
+ DOSET (FLG_FOREMPTY, b);
+ break;
+ case FLG_PREDBOOL:
+ DOSET (FLG_PREDBOOL, b);
+ DOSET (FLG_PREDBOOLINT, b);
+ DOSET (FLG_PREDBOOLPTR, b);
+ DOSET (FLG_PREDBOOLOTHERS, b);
+ break;
+ case FLG_GLOBALIAS:
+ DOSET (FLG_CHECKSTRICTGLOBALIAS, b);
+ DOSET (FLG_CHECKEDGLOBALIAS, b);
+ DOSET (FLG_CHECKMODGLOBALIAS, b);
+ DOSET (FLG_UNCHECKEDGLOBALIAS, b);
+ break;
+ case FLG_ALLBLOCK:
+ DOSET (FLG_ALLBLOCK, b);
+ DOSET (FLG_IFBLOCK, b);
+ DOSET (FLG_WHILEBLOCK, b);
+ DOSET (FLG_FORBLOCK, b);
+ break;
+ case FLG_GRAMMAR:
+ if (b)
{
- DOSET (f, TRUE);
+ yydebug = 1;
+ mtdebug = 1;
}
else
{
- if (b && !gc.anyExports
- && (f == FLG_EXPORTVAR || f == FLG_EXPORTFCN
- || f == FLG_EXPORTTYPE || f == FLG_EXPORTMACRO
- || f == FLG_EXPORTCONST
- || f == FLG_EXPORTANY))
- {
- gc.anyExports = TRUE;
- }
-
- DOSET (f, b);
+ yydebug = 0;
+ mtdebug = 0;
+ }
+
+ DOSET (FLG_GRAMMAR, b);
+ break;
+ case FLG_CODEIMPONLY:
+ DOSET (FLG_CODEIMPONLY, b);
+ DOSET (FLG_GLOBIMPONLY, b);
+ DOSET (FLG_RETIMPONLY, b);
+ DOSET (FLG_STRUCTIMPONLY, b);
+ break;
+ case FLG_SPECALLIMPONLY:
+ DOSET (FLG_SPECALLIMPONLY, b);
+ DOSET (FLG_SPECGLOBIMPONLY, b);
+ DOSET (FLG_SPECRETIMPONLY, b);
+ DOSET (FLG_SPECSTRUCTIMPONLY, b);
+ break;
+ case FLG_ALLIMPONLY:
+ DOSET (FLG_ALLIMPONLY, b);
+ DOSET (FLG_GLOBIMPONLY, b);
+ DOSET (FLG_RETIMPONLY, b);
+ DOSET (FLG_STRUCTIMPONLY, b);
+ DOSET (FLG_SPECGLOBIMPONLY, b);
+ DOSET (FLG_SPECRETIMPONLY, b);
+ DOSET (FLG_SPECSTRUCTIMPONLY, b);
+ break;
+ case FLG_ANSILIMITS:
+ DOSET (FLG_ANSILIMITS, b);
+ DOSET (FLG_CONTROLNESTDEPTH, b);
+ DOSET (FLG_STRINGLITERALLEN, b);
+ DOSET (FLG_INCLUDENEST, b);
+ DOSET (FLG_NUMSTRUCTFIELDS, b);
+ DOSET (FLG_NUMENUMMEMBERS, b);
+
+ if (b)
+ {
+ context_setValue (FLG_CONTROLNESTDEPTH, DEFAULT_CONTROLNESTDEPTH);
+ context_setValue (FLG_STRINGLITERALLEN, DEFAULT_STRINGLITERALLEN);
+ context_setValue (FLG_INCLUDENEST, DEFAULT_INCLUDENEST);
+ context_setValue (FLG_NUMSTRUCTFIELDS, DEFAULT_NUMSTRUCTFIELDS);
+ context_setValue (FLG_NUMENUMMEMBERS, DEFAULT_NUMENUMMEMBERS);
}
+ break;
+ case FLG_EXTERNALNAMELEN:
+ DOSET (FLG_DISTINCTEXTERNALNAMES, TRUE);
+ DOSET (FLG_EXTERNALNAMELEN, TRUE);
+ break;
+ case FLG_INTERNALNAMELEN:
+ DOSET (FLG_DISTINCTINTERNALNAMES, TRUE);
+ DOSET (FLG_INTERNALNAMELEN, TRUE);
+ break;
+ case FLG_EXTERNALNAMECASEINSENSITIVE:
+ DOSET (FLG_EXTERNALNAMECASEINSENSITIVE, b);
+
+ if (b && !gc.flags[FLG_DISTINCTEXTERNALNAMES])
+ {
+ DOSET (FLG_DISTINCTEXTERNALNAMES, TRUE);
+ context_setValue (FLG_EXTERNALNAMELEN, 0);
+ }
+ break;
+ case FLG_INTERNALNAMECASEINSENSITIVE:
+ DOSET (FLG_INTERNALNAMECASEINSENSITIVE, b);
+
+ if (b && !gc.flags[FLG_DISTINCTINTERNALNAMES])
+ {
+ DOSET (FLG_DISTINCTINTERNALNAMES, TRUE);
+ context_setValue (FLG_INTERNALNAMELEN, 0);
+ }
+ break;
+ case FLG_INTERNALNAMELOOKALIKE:
+ DOSET (FLG_INTERNALNAMELOOKALIKE, b);
+
+ if (b && !gc.flags[FLG_DISTINCTINTERNALNAMES])
+ {
+ DOSET (FLG_DISTINCTINTERNALNAMES, TRUE);
+ context_setValue (FLG_INTERNALNAMELEN, 0);
+ }
+ break;
+ case FLG_MODUNSPEC:
+ DOSET (FLG_MODNOMODS, b);
+ DOSET (FLG_MODGLOBSUNSPEC, b);
+ DOSET (FLG_MODSTRICTGLOBSUNSPEC, b);
+ break;
+ case FLG_EXPORTANY:
+ DOSET (FLG_EXPORTVAR, b);
+ DOSET (FLG_EXPORTFCN, b);
+ DOSET (FLG_EXPORTTYPE, b);
+ DOSET (FLG_EXPORTMACRO, b);
+ DOSET (FLG_EXPORTCONST, b);
+ gc.anyExports = TRUE;
+ break;
+ case FLG_REPEXPOSE:
+ DOSET (FLG_RETEXPOSE, b);
+ DOSET (FLG_ASSIGNEXPOSE, b);
+ DOSET (FLG_CASTEXPOSE, b);
+ break;
+ case FLG_RETVAL:
+ DOSET (FLG_RETVALBOOL, b);
+ DOSET (FLG_RETVALINT, b);
+ DOSET (FLG_RETVALOTHER, b);
+ break;
+ case FLG_PARTIAL:
+ if (b)
+ {
+ DOSET (FLG_EXPORTLOCAL, FALSE);
+ DOSET (FLG_DECLUNDEF, FALSE);
+ DOSET (FLG_SPECUNDEF, FALSE);
+ DOSET (FLG_TOPUNUSED, FALSE);
+ }
+ break;
+ case FLG_DEEPBREAK:
+ DOSET (FLG_LOOPLOOPBREAK, b);
+ DOSET (FLG_LOOPSWITCHBREAK, b);
+ DOSET (FLG_SWITCHLOOPBREAK, b);
+ DOSET (FLG_SWITCHSWITCHBREAK, b);
+ DOSET (FLG_LOOPLOOPCONTINUE, b);
+ DOSET (FLG_DEEPBREAK, b);
+ break;
+ case FLG_ACCESSALL:
+ DOSET (FLG_ACCESSMODULE, b);
+ DOSET (FLG_ACCESSFILE, b);
+ DOSET (FLG_ACCESSCZECH, b);
+ break;
+ case FLG_ALLMACROS:
+ DOSET (FLG_ALLMACROS, b);
+ DOSET (FLG_FCNMACROS, b);
+ DOSET (FLG_CONSTMACROS, b);
+ break;
+ case FLG_CZECH:
+ if (b) { DOSET (FLG_ACCESSCZECH, b); }
+ DOSET (FLG_CZECHFUNCTIONS, b);
+ DOSET (FLG_CZECHVARS, b);
+ DOSET (FLG_CZECHCONSTANTS, b);
+ DOSET (FLG_CZECHTYPES, b);
+ break;
+ case FLG_SLOVAK:
+ if (b) { DOSET (FLG_ACCESSSLOVAK, b); }
+ DOSET (FLG_SLOVAKFUNCTIONS, b);
+ DOSET (FLG_SLOVAKVARS, b);
+ DOSET (FLG_SLOVAKCONSTANTS, b);
+ DOSET (FLG_SLOVAKTYPES, b);
+ break;
+ case FLG_CZECHOSLOVAK:
+ if (b) { DOSET (FLG_ACCESSCZECHOSLOVAK, b); }
+ DOSET (FLG_CZECHOSLOVAKFUNCTIONS, b);
+ DOSET (FLG_CZECHOSLOVAKVARS, b);
+ DOSET (FLG_CZECHOSLOVAKCONSTANTS, b);
+ DOSET (FLG_CZECHOSLOVAKTYPES, b);
+ break;
+ case FLG_NULL:
+ DOSET (FLG_NULLSTATE, b);
+ DOSET (FLG_NULLDEREF, b);
+ DOSET (FLG_NULLASSIGN, b);
+ DOSET (FLG_NULLPASS, b);
+ DOSET (FLG_NULLRET, b);
+ break;
+ case FLG_MEMCHECKS:
+ DOSET (FLG_NULLSTATE, b);
+ DOSET (FLG_NULLDEREF, b);
+ DOSET (FLG_NULLASSIGN, b);
+ DOSET (FLG_NULLPASS, b);
+ DOSET (FLG_NULLRET, b);
+ DOSET (FLG_COMPDEF, b);
+ DOSET (FLG_COMPMEMPASS, b);
+ DOSET (FLG_UNIONDEF, b);
+ DOSET (FLG_MEMTRANS, b);
+ DOSET (FLG_USERELEASED, b);
+ DOSET (FLG_ALIASUNIQUE, b);
+ DOSET (FLG_MAYALIASUNIQUE, b);
+ DOSET (FLG_MUSTFREE, b);
+ DOSET (FLG_MUSTDEFINE, b);
+ DOSET (FLG_GLOBSTATE, b);
+ DOSET (FLG_COMPDESTROY, b);
+ DOSET (FLG_MUSTNOTALIAS, b);
+ DOSET (FLG_MEMIMPLICIT, b);
+ DOSET (FLG_BRANCHSTATE, b);
+ /*@fallthrough@*/ /* also sets memtrans flags */
+ case FLG_MEMTRANS:
+ DOSET (FLG_MEMTRANS, b);
+ DOSET (FLG_EXPOSETRANS, b);
+ DOSET (FLG_OBSERVERTRANS, b);
+ DOSET (FLG_DEPENDENTTRANS, b);
+ DOSET (FLG_NEWREFTRANS, b);
+ DOSET (FLG_ONLYTRANS, b);
+ DOSET (FLG_OWNEDTRANS, b);
+ DOSET (FLG_FRESHTRANS, b);
+ DOSET (FLG_SHAREDTRANS, b);
+ DOSET (FLG_TEMPTRANS, b);
+ DOSET (FLG_KEPTTRANS, b);
+ DOSET (FLG_REFCOUNTTRANS, b);
+ DOSET (FLG_STATICTRANS, b);
+ DOSET (FLG_UNKNOWNTRANS, b);
+ DOSET (FLG_KEEPTRANS, b);
+ DOSET (FLG_IMMEDIATETRANS, b);
+ break;
+
+ default:
+ break;
+ }
+
+ if (b && !gc.anyExports
+ && (f == FLG_EXPORTVAR || f == FLG_EXPORTFCN
+ || f == FLG_EXPORTTYPE || f == FLG_EXPORTMACRO
+ || f == FLG_EXPORTCONST
+ || f == FLG_EXPORTANY))
+ {
+ gc.anyExports = TRUE;
}
}
return (gc.flags[d]);
}
+bool
+context_flagOn (flagcode f, fileloc loc)
+{
+ return (!context_suppressFlagMsg (f, loc));
+}
+
static void context_saveFlagSettings (void)
{
gc.savedFlags = TRUE;
void context_enterIterDef (/*@observer@*/ uentry le)
{
- context_enterMacro (le);
+ context_enterMacro (le);
gc.acct = typeIdSet_subtract (gc.facct, gc.nacct);
gc.kind = CX_ITERDEF;
}
void context_enterIterEnd (/*@observer@*/ uentry le)
{
- context_enterMacro (le);
+ context_enterMacro (le);
gc.kind = CX_ITEREND;
}
cstring_free (gc.msgAnnote);
globSet_free (gc.globs_used);
- }
+ metaStateTable_free (gc.stateTable);
+ annotationTable_free (gc.annotTable);
+}
/*
** Flag shortcuts.
void context_hasError (void)
{
gc.numerrors++;
+ DPRINTF (("num errors: %d", gc.numerrors));
}
int context_numErrors (void)
return (gc.kind == CX_MACROCONST);
}
-bool context_inMacroUnknown (void)
+bool context_inUnknownMacro (void)
{
return (gc.kind == CX_UNKNOWNMACRO);
}
return (gc.kind == CX_GLOBAL);
}
+static void context_quietExitScopes (void)
+{
+ /*
+ ** Try to restore the global scope (after an error).
+ */
+
+ while (!usymtab_inFileScope ())
+ {
+ usymtab_quietExitScope (g_currentloc);
+ }
+
+ gc.cont.glob = TRUE;
+ gc.kind = CX_GLOBAL;
+}
+
+void context_checkGlobalScope (void)
+{
+ if (gc.kind != CX_GLOBAL)
+ {
+ if (context_inMacro ())
+ {
+ ; /* evans 2001-10-14: Okay to be in a macro here! */
+ }
+ else
+ {
+ llcontbug (message ("Not in global scope as expected: %q", context_unparse ()));
+ context_quietExitScopes ();
+ }
+ }
+}
+
void context_setFileId (fileId s)
{
g_currentloc = fileloc_updateFileId (g_currentloc, s);
return (gc.macroMissingParams);
}
+void context_showFilelocStack (void)
+{
+ filelocStack_printIncludes (gc.locstack);
+}
+
+metaStateTable context_getMetaStateTable (void)
+{
+ return gc.stateTable;
+}
+
+metaStateInfo context_lookupMetaStateInfo (cstring key)
+{
+ return metaStateTable_lookup (gc.stateTable, key);
+}
+
+/*@null@*/ annotationInfo context_lookupAnnotation (cstring annot)
+{
+ annotationInfo ainfo;
+ ainfo = annotationTable_lookup (gc.annotTable, annot);
+ return ainfo;
+}
+
+void context_addAnnotation (annotationInfo ainfo)
+{
+ if (annotationTable_contains (gc.annotTable, annotationInfo_getName (ainfo)))
+ {
+ voptgenerror
+ (FLG_SYNTAX,
+ message ("Duplicate annotation declaration: %s", annotationInfo_getName (ainfo)),
+ annotationInfo_getLoc (ainfo));
+
+ annotationInfo_free (ainfo);
+ }
+ else
+ {
+ annotationTable_insert (gc.annotTable, ainfo);
+ }
+}
+
+void context_addMetaState (cstring mname, metaStateInfo msinfo)
+{
+ if (metaStateTable_contains (gc.stateTable, mname))
+ {
+ voptgenerror
+ (FLG_SYNTAX,
+ message ("Duplicate metastate declaration: %s", mname),
+ metaStateInfo_getLoc (msinfo));
+ cstring_free (mname);
+ metaStateInfo_free (msinfo);
+ }
+ else
+ {
+ DPRINTF (("Adding meta state: %s", mname));
+ metaStateTable_insert (gc.stateTable, mname, msinfo);
+ }
+}
+valueTable context_createValueTable (sRef s, stateInfo sinfo)
+{
+ if (metaStateTable_size (gc.stateTable) > 0)
+ {
+ valueTable res = valueTable_create (metaStateTable_size (gc.stateTable));
+ /*@i32 should use smaller value... */
+ DPRINTF (("Value table for: %s", sRef_unparse (s)));
+
+ metaStateTable_elements (gc.stateTable, msname, msi)
+ {
+ mtContextNode context = metaStateInfo_getContext (msi);
+ if (mtContextNode_matchesRefStrict (context, s))
+ {
+ DPRINTF (("Create: %s", metaStateInfo_unparse (msi)));
+ llassert (cstring_equal (msname, metaStateInfo_getName (msi)));
+
+ valueTable_insert
+ (res,
+ cstring_copy (metaStateInfo_getName (msi)),
+ stateValue_createImplicit (metaStateInfo_getDefaultValue (msi, s),
+ stateInfo_copy (sinfo)));
+ }
+ else
+ {
+ DPRINTF (("No match: %s", metaStateInfo_unparse (msi)));
+ }
+ }
+ end_metaStateTable_elements ;
+
+ stateInfo_free (sinfo);
+ DPRINTF (("Value table: %s", valueTable_unparse (res)));
+ return res;
+ }
+ else
+ {
+ stateInfo_free (sinfo);
+ return valueTable_undefined;
+ }
+}
+valueTable context_createGlobalMarkerValueTable (stateInfo sinfo)
+{
+ if (metaStateTable_size (gc.stateTable) > 0)
+ {
+ valueTable res = valueTable_create (metaStateTable_size (gc.stateTable));
+ /*@i32 should use smaller value... */
+
+ metaStateTable_elements (gc.stateTable, msname, msi)
+ {
+ /*@i23 only add global...*/
+ DPRINTF (("Create: %s", metaStateInfo_unparse (msi)));
+ llassert (cstring_equal (msname, metaStateInfo_getName (msi)));
+
+ valueTable_insert (res,
+ cstring_copy (metaStateInfo_getName (msi)),
+ stateValue_create (metaStateInfo_getDefaultGlobalValue (msi),
+ stateInfo_copy (sinfo)));
+ }
+ end_metaStateTable_elements ;
+
+ stateInfo_free (sinfo);
+ DPRINTF (("Value table: %s", valueTable_unparse (res)));
+ return res;
+ }
+ else
+ {
+ stateInfo_free (sinfo);
+ return valueTable_undefined;
+ }
+}