[splint.git] / src / fileloc.c

/*
** Splint - annotation-assisted static program checker
** Copyright (C) 1994-2002 University of Virginia,
**         Massachusetts Institute of Technology
**
** This program is free software; you can redistribute it and/or modify it
** under the terms of the GNU General Public License as published by the
** Free Software Foundation; either version 2 of the License, or (at your
** option) any later version.
** 
** This program is distributed in the hope that it will be useful, but
** WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
** General Public License for more details.
** 
** The GNU General Public License is available from http://www.gnu.org/ or
** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
** MA 02111-1307, USA.
**
** For information on splint: info@splint.org
** To report a bug: splint-bug@splint.org
** For more information: http://www.splint.org
*/
/*
** fileloc.c
*/
/*
 * Modified by Herbert 04/19/97:
 * - added new include file portab.h.
 * - added new private function fileloc_filenameForCpp() to handle
 *   filenames belonging to "#line" statements for OS/2 and MSDOS. It
 *   gets called by fileloc_lineMarker() and fileloc_previousLineMarker()
 *   instead of fileloc_unparseFilename().
 */

# include "splintMacros.nf"
# include "llbasic.h"
# include "fileIdList.h"
# include "osd.h"
# include "portab.h"

static /*@only@*/ fileloc fileloc_createPrim (flkind p_kind, fileId p_fid, int p_line, int p_col);

static flkind fileId_kind (fileId s)
{
  cstring fname = fileTable_rootFileName (s);
  
  if (fileLib_isLCLFile (fname))
    {
      return (FL_SPEC);
    }
  else if (cstring_equalPrefix (fname, cstring_makeLiteralTemp (SYSTEM_LIBDIR)))
    {
      return (FL_STDHDR); 
    }
  else
    {
      return (FL_NORMAL);
    }
}  

fileloc
fileloc_decColumn (fileloc f, int x)
{
  fileloc ret = fileloc_copy (f);

  if (x > 0 && fileloc_isDefined (ret))
    {
      llassertprint (ret->column > x, ("decColumn: %d", x));
      ret->column -= x;
    }

  return ret;
}

fileloc
fileloc_noColumn (fileloc f)
{
  if (fileloc_isDefined (f))
    {
      fileloc ret = fileloc_copy (f);

      if (fileloc_isDefined (ret))
	{
	  ret->column = 0;
	}

      return ret;
    }
  else
    {
      return fileloc_undefined;
    }
}

void
fileloc_subColumn (fileloc f, int x)
{
  if (x > 0 && fileloc_isDefined (f))
    {
      llassert (f->column > x);
      f->column -= x;
    }
}

fileloc fileloc_copy (fileloc f)
{
  if (fileloc_isDefined (f))
    {
      if (fileloc_isBuiltin (f) || fileloc_isExternal (f))
	{
	  /*
	  ** Legitimate (spurious) errors reported since no copy
	  ** is made.
	  */

	  /*@i3@*/ return f; /* No copy is necessary. */
	}
      else
	{
	  return (fileloc_createPrim (f->kind, f->fid, f->lineno, f->column));
	}
    }
  else
    {
      return fileloc_undefined;
    }
}

fileloc fileloc_update (/*@only@*/ fileloc old, fileloc fnew)
{
  if (fileloc_isUndefined (fnew))
    {
      fileloc_free (old);
      return fileloc_undefined;
    }
  else if (fileloc_isUndefined (old) || fileloc_isBuiltin (old) || fileloc_isExternal (old))
    {
      return (fileloc_copy (fnew));
    }
  else
    {
      old->kind   = fnew->kind;
      old->fid    = fnew->fid; 
      old->lineno = fnew->lineno;
      old->column = fnew->column;

      return old;
    }
}

fileloc fileloc_updateFileId (/*@only@*/ fileloc old, fileId s)
{
  if (fileloc_isUndefined (old) || fileloc_isBuiltin (old) || fileloc_isExternal (old))
    {
      return (fileloc_create (s, 1, 1));
    }
  else
    {
      old->kind   = fileId_kind (s);
      old->fid    = s; 
      old->lineno = 1;
      old->column = 1;

      return old;
    }
}

void
fileloc_free (/*@only@*/ fileloc f)
{
  if (fileloc_isDefined (f))
    {
      if (f != g_currentloc)
	{
	  if (fileloc_isBuiltin (f) || fileloc_isExternal (f))
	    {
	      ; /* don't free */
	    }
	  else
	    {
	      sfree (f);  
	      /*@-branchstate@*/ 
	    } 
	}
      else
	{
	  ; /* Don't free g_currentloc ever! */
	}
      /*@=branchstate@*/
    }
}

void
fileloc_reallyFree (/*@only@*/ fileloc f)
{
  if (fileloc_isDefined (f))
    {
      if (fileloc_isBuiltin (f) || fileloc_isExternal (f))
	{
	  ; /* don't free */
	}
      else
	{
	  sfree (f);  
	/*@-branchstate@*/ } /*@=branchstate@*/
    }
}

cstring fileloc_getBase (fileloc f)
{
  llassert (fileloc_isDefined (f));

  return (fileTable_fileNameBase (f->fid));
}

bool
fileloc_equal (fileloc f1, fileloc f2)
{
  return ((f1 == f2)
	  || (fileloc_isDefined (f1) && fileloc_isDefined (f2) 
	      && ((f1->column == f2->column) && 
		  (f1->lineno == f2->lineno) && fileloc_sameFile (f1, f2))));
}

int
fileloc_compare (fileloc f1, fileloc f2)
{
  if (fileloc_isUndefined (f1))
    {
      if (fileloc_isUndefined (f2)) return 0;
      return -1;
    }
  
  if (fileloc_isUndefined (f2))
    return 1;

  /*@access fileId@*/ 
  INTCOMPARERETURN (f1->fid, f2->fid); 
  /*@noaccess fileId@*/


  /* drl 8-11-01 fix what I think is a bug
     lineno should more important than column number*/

  INTCOMPARERETURN (f1->lineno, f2->lineno);   
  INTCOMPARERETURN (f1->column, f2->column);
  
  return 0;
}

bool
fileloc_withinLines (fileloc f1, fileloc f2, int n)
{
  
  return (fileloc_isDefined (f1) && 
	  fileloc_isDefined (f2) &&
	  ((f2->lineno <= f1->lineno + n) 
	   && (f2->lineno >= f1->lineno)
	   && fileloc_sameFile (f1, f2)));
}

bool
fileloc_lessthan (fileloc f1, fileloc f2)
{
  /*@access fileId*/
  return ((fileloc_isDefined (f1) && fileloc_isDefined (f2))
	  && ((f1->fid < f2->fid)
	      || ((f1->fid == f2->fid)
		  && ((f1->lineno < f2->lineno)
		      || ((f1->lineno == f2->lineno)
			  && (f1->column < f2->column))))));
  /*@noaccess fileId*/
}

/*
** returns true if f1 and f2 are different files,
** or f1 is before f2 in same file
*/

bool
fileloc_notAfter (fileloc f1, fileloc f2)
{
  /*@access fileId*/
  return ((fileloc_isDefined (f1) && fileloc_isDefined (f2))
	  && ((f1->fid != f2->fid)
	      || ((f1->lineno < f2->lineno)
		  || ((f1->lineno == f2->lineno)
		      && (f1->column <= f2->column)))));
  /*@noaccess fileId@*/
}

# ifndef NOLCL
bool
fileloc_isStandardLibrary (fileloc f)
{
  cstring s = fileloc_getBase (f);

  return (cstring_equalLit (s, LLSTDLIBS_NAME)
	  || cstring_equalLit (s, LLSTRICTLIBS_NAME)
	  || cstring_equalLit (s, LLUNIXLIBS_NAME)
	  || cstring_equalLit (s, LLUNIXSTRICTLIBS_NAME)
	  || cstring_equalLit (s, LLPOSIXSTRICTLIBS_NAME)
	  || cstring_equalLit (s, LLPOSIXLIBS_NAME));
}
# endif

bool
fileloc_sameFileAndLine (fileloc f1, fileloc f2)
{
  return (fileloc_sameFile (f1, f2)
	  && (fileloc_isDefined (f1) && fileloc_isDefined (f2)
	      && f1->lineno == f2->lineno));
}

bool
fileloc_sameFile (fileloc f1, fileloc f2)
{
  if ((fileloc_isUndefined (f1) || (fileloc_isUndefined (f2)) 
       || (fileloc_isLib (f1)) || (fileloc_isLib (f2))))
    {
      return FALSE;
    }
  else
    {
      return (fileId_equal (f1->fid, f2->fid));
    }
}

bool
fileloc_sameModule (fileloc f1, fileloc f2)
{
  if (fileloc_isUndefined (f1))
    {
      return (fileloc_isUndefined (f2));
    }
  else if (fileloc_isUndefined (f2))
    {
      return (FALSE);
    }
  else
    {
      if (fileloc_isBuiltin (f1) || fileloc_isBuiltin (f2)
	  || fileloc_isExternal (f1) || fileloc_isExternal (f2))
	{
	  return fileloc_sameFile (f1, f2);
	}
      else
	{
	  cstring s1 = fileloc_getBase (f1);
	  cstring s2 = fileloc_getBase (f2);
	  
	  return (cstring_equal (s1, s2));
	}
    }
}

bool
fileloc_sameBaseFile (fileloc f1, fileloc f2)
{
  if (fileloc_isUndefined (f1))
    {
      return (fileloc_isUndefined (f2));
    }
  else if (fileloc_isUndefined (f2))
    {
      return (FALSE);
    }
  else
    {
      return (fileId_baseEqual (f1->fid, f2->fid));
    }
}

bool fileloc_isSystemFile (fileloc f1)
{
  if (fileloc_isDefined (f1)
      && !fileloc_isBuiltin (f1)
      && !fileloc_isExternal (f1))
    {
      return (fileTable_isSystemFile (context_fileTable (), f1->fid));
    }

  return FALSE;
}

bool fileloc_isXHFile (fileloc f1)
{
  if (fileloc_isDefined (f1)
      && !fileloc_isBuiltin (f1)
      && !fileloc_isExternal (f1))
    {
      DPRINTF (("Fileloc is XH: [%p] %s", f1, fileloc_unparse (f1)));
      return (fileTable_isXHFile (context_fileTable (), f1->fid));
    }
  
  return FALSE;
}

bool
fileloc_almostSameFile (fileloc f1, fileloc f2)
{
  if ((fileloc_isUndefined (f1) || (fileloc_isUndefined (f2)) 
       || (fileloc_isLib (f1)) || (fileloc_isLib (f2))))
    {
      return FALSE;
    }
  else
    {
      if (fileId_baseEqual (f1->fid, f2->fid))
	{
	  return TRUE;
	}
      else if (fileTable_isSystemFile (context_fileTable (), f1->fid)
	       || fileTable_isSystemFile (context_fileTable (), f2->fid))
	{
	  return TRUE;
	}
      else if (fileTable_isSpecialFile (context_fileTable (), f1->fid)
	       || fileTable_isSpecialFile (context_fileTable (), f2->fid))
	{
	  return (cstring_equal (fileloc_getBase (f1), 
				 fileloc_getBase (f2)));
	}
      else 
	{
	  return FALSE;
	}
    }
}

# ifndef NOLCL
/*@only@*/ fileloc
fileloc_fromTok (ltoken t) 
{
  cstring fname = ltoken_fileName (t);
  fileId fid = fileTable_lookup (context_fileTable (), fname);
  fileloc fl;

  if (!fileId_isValid (fid))
    {
      fid = fileTable_addLCLFile (context_fileTable (), fname);
    }
  
  fl = fileloc_create (fid, (int) ltoken_getLine (t), (int) ltoken_getCol (t));
  
  return (fl);
}
# endif

/*@only@*/ fileloc
fileloc_createLib (cstring ln)
{
  flkind fk = FL_LIB;
  fileId fid = fileTable_lookup (context_fileTable (), ln);

  if (!fileId_isValid (fid))
    {
      fid = fileTable_addLibraryFile (context_fileTable (), ln);
    }

  if (cstring_equalPrefix (ln, cstring_makeLiteralTemp (SYSTEM_LIBDIR)))
    {
      fk = FL_STDLIB;
    }

  return (fileloc_createPrim (fk, fid, 0, 0));
}

fileloc fileloc_createRc (cstring name)
{
  fileId fid = fileTable_addFile (context_fileTable (), name);

  return (fileloc_createPrim (FL_RC, fid, 0, 0));
}

fileloc fileloc_createExternal (void)
{
  /*@i@*/ return (fileloc_getExternal ()); 
}

fileloc fileloc_getExternal (void)
{
  static /*@owned@*/ fileloc res = fileloc_undefined;

  if (res == fileloc_undefined) 
    {
      res = fileloc_createPrim (FL_EXTERNAL, fileId_invalid, 0, 0);
    }

  return res;
}

fileloc fileloc_observeBuiltin ()
{
  /*@-onlytrans@*/ return (fileloc_getBuiltin ()); /*@=onlytrans@*/
}

fileloc fileloc_getBuiltin ()
{
  static /*@owned@*/ fileloc res = fileloc_undefined;

  if (res == fileloc_undefined)
    {
      res = fileloc_createPrim (FL_BUILTIN, fileId_invalid, 0, 0); 
    }

  return res;
}

fileloc
fileloc_makePreproc (fileloc loc)
{
  if (fileloc_isDefined (loc))
    {
      return (fileloc_createPrim (FL_PREPROC, loc->fid, 
				  loc->lineno, loc->column));
    }

  return (fileloc_createPrim (FL_PREPROC, fileId_invalid, 0, 0));
}

fileloc
fileloc_makePreprocPrevious (fileloc loc)
{
  if (fileloc_isDefined (loc))
    {
      if (loc->lineno > 1)
	{
	  return (fileloc_createPrim (FL_PREPROC, loc->fid,
				      loc->lineno - 1, 0));
	}
      else
	{
	  return (fileloc_createPrim (FL_PREPROC, loc->fid,
				      loc->lineno, 0));
	}
    }

  return (fileloc_createPrim (FL_PREPROC, fileId_invalid, 0, 0));
}

/*@only@*/ fileloc
fileloc_createBuiltin ()
{
  return (fileloc_createPrim (FL_BUILTIN, fileId_invalid, 0, 0)); 
}

# ifndef NOLCL
/*@only@*/ fileloc
fileloc_createImport (cstring fname, int lineno)
{
  fileId fid = fileTable_lookup (context_fileTable (), fname);

  if (!fileId_isValid (fid))
    {
      fid = fileTable_addImportFile (context_fileTable (), fname);
    }

  return (fileloc_createPrim (FL_IMPORT, fid, lineno, 0));
}
# endif

static /*@only@*/ fileloc
fileloc_createPrim (flkind kind, fileId fid, int line, int col)
{
  fileloc f = (fileloc) dmalloc (sizeof (*f));
  
  f->kind   = kind;
  f->fid    = fid; 
  f->lineno = line;
  f->column = col;

  DPRINTF (("Fileloc create: [%p] %s", f, fileloc_unparse (f)));
  return (f);
}

# ifndef NOLCL
/*@only@*/ fileloc
fileloc_createSpec (fileId fid, int line, int col)
{
  return (fileloc_createPrim (FL_SPEC, fid, line, col));
}
# endif

fileloc fileloc_create (fileId fid, int line, int col)
{
  return (fileloc_createPrim (fileId_kind (fid), fid, line, col));
}

/*@observer@*/ cstring
fileloc_filename (fileloc f)
{
  return (fileloc_isDefined (f) ? fileTable_rootFileName (f->fid) : cstring_makeLiteralTemp ("<unknown>"));
}

/*@only@*/ cstring fileloc_outputFilename (fileloc f)
{
  if (fileloc_isDefined (f))
    {
      return osd_outputPath (fileTable_rootFileName (f->fid));
    }
  else
    {
      return cstring_makeLiteral ("<unknown>");
    }
}

cstring
fileloc_unparseFilename (fileloc f)
{
  if (fileloc_isDefined (f))
    {
      switch (f->kind)
	{
	case FL_LIB:
	  return (message ("load file %q", fileloc_outputFilename (f)));
	case FL_BUILTIN:
	  return (cstring_makeLiteral ("# builtin #"));
	case FL_IMPORT:
	  return (message ("import file %q", fileloc_outputFilename (f)));
	case FL_EXTERNAL:
	  return (cstring_makeLiteral ("<external>"));
	default: 
	  return (fileloc_outputFilename (f));
	}
    }
  return cstring_undefined;
}

int
fileloc_lineno (fileloc f)
{
  return (fileloc_isDefined (f) ? f->lineno : -1);
}

int
fileloc_column (fileloc f)
{
  return (fileloc_isDefined (f) ? f->column : -1);
}

/*@only@*/ cstring
fileloc_unparse (fileloc f)
{
  bool parenFormat = context_getFlag (FLG_PARENFILEFORMAT); 

  if (fileloc_isDefined (f))
    {
       switch (f->kind)
	{
	case FL_BUILTIN:
	  return (cstring_makeLiteral ("Command Line"));
	case FL_IMPORT:
	  if (parenFormat)
	    {
	      return (message ("import file %q(%d)", fileloc_outputFilename (f), f->lineno));
	    }
	  else
	    {
	      return (message ("import file %q:%d", fileloc_outputFilename (f), f->lineno));
	    }
	case FL_PREPROC:
	  if (parenFormat)
	    {
	      return (message ("%q(%d)", fileloc_outputFilename (f), f->lineno));
	    }
	  else
	    {
	      return (message ("%q:%d", fileloc_outputFilename (f), f->lineno));
	    }
	case FL_EXTERNAL:
	  return (cstring_makeLiteral ("<external>"));
	default:
	  {
	    cstring fname;
	    
	    if (f->kind == FL_LIB)
	      {
		fname = message ("load file %q", fileloc_outputFilename (f));
	      }
	    else
	      {
		fname = fileloc_outputFilename (f);
	      }

	    if (context_getFlag (FLG_SHOWCOL))
	      {
		if (fileloc_linenoDefined (f))
		  {
		    if (fileloc_columnDefined (f))
		      {
			if (parenFormat)
			  {
			    return (message ("%q(%d,%d)", fname, f->lineno, f->column));
			  }
			else
			  {
			    return (message ("%q:%d:%d", fname, f->lineno, f->column));
			  }
		      }
		    else
		      {
			if (parenFormat)
			  {
			    return (message ("%q(%d)", fname, f->lineno));
			  }
			else
			  {
			    return (message ("%q:%d", fname, f->lineno));
			  }
		      }
		  }
		
		return fname;
	      }
	    else if (fileloc_linenoDefined (f))
	      {
		if (parenFormat)
		  {
		    return (message ("%q(%d)", fname, f->lineno));
		  }
		else
		  {
		    return (message ("%q:%d", fname, f->lineno));
		  }
	      }
	    else
	      {
		return fname;
	      }
	  }
	}
    }

  return (cstring_makeLiteral ("< Location unknown >"));
}

/*@only@*/ cstring
fileloc_unparseRaw (cstring fname, int lineno)
{
  bool parenFormat = context_getFlag (FLG_PARENFILEFORMAT); 

  if (parenFormat)
    {
      return (message ("%q(%d)", osd_outputPath (fname), lineno));
    }
  else
    {
      return (message ("%q:%d", osd_outputPath (fname), lineno));
    }
}

/*@only@*/ cstring
fileloc_unparseRawCol (cstring fname, int lineno, int col)
{
  if (context_getFlag (FLG_SHOWCOL)) 
    {
      bool parenFormat = context_getFlag (FLG_PARENFILEFORMAT); 
      
      if (parenFormat)
	{
	  return (message ("%q(%d,%d)", osd_outputPath (fname), lineno, col));
	}
      else
	{
	  return (message ("%q:%d:%d", osd_outputPath (fname), lineno, col));
	}
    }
  else
    {
      return fileloc_unparseRaw (fname, lineno);
    }
}

bool fileloc_isSpecialFile (fileloc f)
{
  if (fileloc_isDefined (f) 
      && fileId_isValid (f->fid))
    {
      return (fileTable_isSpecialFile (context_fileTable (), f->fid));
    }
  else
    {
      return FALSE;
    }
}

bool fileloc_isHeader (fileloc f)
{
  /* returns true if is not a .c file */

  return (fileloc_isDefined (f) && fileId_isValid (f->fid)
	  && fileId_isHeader (f->fid));
}

bool fileloc_isSpec (fileloc f)
{
  return (fileloc_isDefined (f) && 
	  (f->kind == FL_LIB || f->kind == FL_STDLIB || f->kind == FL_SPEC));
}

bool fileloc_isRealSpec (fileloc f)
{
  return (fileloc_isDefined (f) && (f->kind == FL_SPEC));
}

bool fileloc_isLib (fileloc f)
{
  return (fileloc_isDefined (f) 
	  && (f->kind == FL_LIB || f->kind == FL_STDHDR || f->kind == FL_STDLIB));
}

bool fileloc_isStandardLib (fileloc f)
{
  return (fileloc_isDefined (f) && f->kind == FL_STDLIB);
}

/*@only@*/ cstring fileloc_unparseDirect (fileloc fl)
{
  if (fileloc_isDefined (fl))
    {
      return (message ("%d:%d:%d",
		       /*@access fileId@*/ (int) fl->fid, /*@noaccess fileId@*/
		       fl->lineno, fl->column));
    }
  else
    {
      return (cstring_makeLiteral ("<undef>"));
    }
}

bool fileloc_isUser (fileloc f)
{
  return (fileloc_isDefined (f) 
	  && f->kind == FL_NORMAL);
}
Commit	Line	Data
616915dd	1	/*
11db3170	2	** Splint - annotation-assisted static program checker
77d37419	3	** Copyright (C) 1994-2002 University of Virginia,
616915dd	4	** Massachusetts Institute of Technology
	5	**
	6	** This program is free software; you can redistribute it and/or modify it
	7	** under the terms of the GNU General Public License as published by the
	8	** Free Software Foundation; either version 2 of the License, or (at your
	9	** option) any later version.
	10	**
	11	** This program is distributed in the hope that it will be useful, but
	12	** WITHOUT ANY WARRANTY; without even the implied warranty of
	13	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	** General Public License for more details.
	15	**
	16	** The GNU General Public License is available from http://www.gnu.org/ or
	17	** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	18	** MA 02111-1307, USA.
	19	**
155af98d	20	** For information on splint: info@splint.org
155af98d	21	** To report a bug: splint-bug@splint.org
11db3170	22	** For more information: http://www.splint.org
616915dd	23	*/
	24	/*
	25	** fileloc.c
	26	*/
	27	/*
	28	* Modified by Herbert 04/19/97:
	29	* - added new include file portab.h.
	30	* - added new private function fileloc_filenameForCpp() to handle
	31	* filenames belonging to "#line" statements for OS/2 and MSDOS. It
	32	* gets called by fileloc_lineMarker() and fileloc_previousLineMarker()
	33	* instead of fileloc_unparseFilename().
	34	*/
	35
1b8ae690	36	# include "splintMacros.nf"
616915dd	37	# include "llbasic.h"
616915dd	38	# include "fileIdList.h"
53a89507	39	# include "osd.h"
616915dd	40	# include "portab.h"
	41
	42	static /@only@/ fileloc fileloc_createPrim (flkind p_kind, fileId p_fid, int p_line, int p_col);
	43
	44	static flkind fileId_kind (fileId s)
	45	{
4dd72714	46	cstring fname = fileTable_rootFileName (s);
616915dd	47
28bf4b0b	48	if (fileLib_isLCLFile (fname))
616915dd	49	{
	50	return (FL_SPEC);
	51	}
68de3f33	52	else if (cstring_equalPrefix (fname, cstring_makeLiteralTemp (SYSTEM_LIBDIR)))
616915dd	53	{
	54	return (FL_STDHDR);
	55	}
	56	else
	57	{
	58	return (FL_NORMAL);
	59	}
	60	}
	61
	62	fileloc
	63	fileloc_decColumn (fileloc f, int x)
	64	{
	65	fileloc ret = fileloc_copy (f);
68de3f33	66
616915dd	67	if (x > 0 && fileloc_isDefined (ret))
	68	{
	69	llassertprint (ret->column > x, ("decColumn: %d", x));
	70	ret->column -= x;
	71	}
	72
	73	return ret;
	74	}
	75
	76	fileloc
	77	fileloc_noColumn (fileloc f)
	78	{
	79	if (fileloc_isDefined (f))
	80	{
	81	fileloc ret = fileloc_copy (f);
	82
	83	if (fileloc_isDefined (ret))
	84	{
	85	ret->column = 0;
	86	}
	87
	88	return ret;
	89	}
	90	else
	91	{
	92	return fileloc_undefined;
	93	}
	94	}
	95
	96	void
	97	fileloc_subColumn (fileloc f, int x)
	98	{
	99	if (x > 0 && fileloc_isDefined (f))
	100	{
	101	llassert (f->column > x);
	102	f->column -= x;
	103	}
	104	}
	105
	106	fileloc fileloc_copy (fileloc f)
	107	{
	108	if (fileloc_isDefined (f))
	109	{
	110	if (fileloc_isBuiltin (f) \|\| fileloc_isExternal (f))
	111	{
	112	/*
	113	** Legitimate (spurious) errors reported since no copy
	114	** is made.
	115	*/
	116
	117	/@i3@/ return f; /* No copy is necessary. */
	118	}
	119	else
	120	{
	121	return (fileloc_createPrim (f->kind, f->fid, f->lineno, f->column));
	122	}
	123	}
	124	else
	125	{
	126	return fileloc_undefined;
	127	}
	128	}
	129
	130	fileloc fileloc_update (/@only@/ fileloc old, fileloc fnew)
131	{
132	if (fileloc_isUndefined (fnew))
133	{
134	fileloc_free (old);
135	return fileloc_undefined;
136	}
137	else if (fileloc_isUndefined (old) \|\| fileloc_isBuiltin (old) \|\| fileloc_isExternal (old))
138	{
139	return (fileloc_copy (fnew));
140	}
141	else
142	{
143	old->kind = fnew->kind;
144	old->fid = fnew->fid;
145	old->lineno = fnew->lineno;
146	old->column = fnew->column;
147
148	return old;
149	}
150	}
151
152	fileloc fileloc_updateFileId (/@only@/ fileloc old, fileId s)
153	{
154	if (fileloc_isUndefined (old) \|\| fileloc_isBuiltin (old) \|\| fileloc_isExternal (old))
155	{
156	return (fileloc_create (s, 1, 1));
157	}
158	else
159	{
160	old->kind = fileId_kind (s);
161	old->fid = s;
162	old->lineno = 1;
163	old->column = 1;
164
165	return old;
166	}
167	}
168
169	void
170	fileloc_free (/@only@/ fileloc f)
171	{
172	if (fileloc_isDefined (f))
173	{
174	if (f != g_currentloc)
175	{
176	if (fileloc_isBuiltin (f) \|\| fileloc_isExternal (f))
177	{
178	; /* don't free */
179	}
180	else
181	{
ccf0a4a8	182	sfree (f);
616915dd	183	/@-branchstate@/
	184	}
	185	}
	186	else
	187	{
ccf0a4a8	188	; /* Don't free g_currentloc ever! */
ccf0a4a8	189	}
616915dd	190	/@=branchstate@/
	191	}
	192	}
	193
	194	void
	195	fileloc_reallyFree (/@only@/ fileloc f)
	196	{
	197	if (fileloc_isDefined (f))
	198	{
	199	if (fileloc_isBuiltin (f) \|\| fileloc_isExternal (f))
	200	{
	201	; /* don't free */
	202	}
	203	else
	204	{
	205	sfree (f);
	206	/@-branchstate@/ } /@=branchstate@/
	207	}
	208	}
	209
	210	cstring fileloc_getBase (fileloc f)
	211	{
	212	llassert (fileloc_isDefined (f));
	213
4dd72714	214	return (fileTable_fileNameBase (f->fid));
616915dd	215	}
	216
	217	bool
	218	fileloc_equal (fileloc f1, fileloc f2)
	219	{
	220	return ((f1 == f2)
	221	\|\| (fileloc_isDefined (f1) && fileloc_isDefined (f2)
	222	&& ((f1->column == f2->column) &&
	223	(f1->lineno == f2->lineno) && fileloc_sameFile (f1, f2))));
	224	}
	225
	226	int
	227	fileloc_compare (fileloc f1, fileloc f2)
	228	{
	229	if (fileloc_isUndefined (f1))
	230	{
	231	if (fileloc_isUndefined (f2)) return 0;
	232	return -1;
	233	}
	234
	235	if (fileloc_isUndefined (f2))
	236	return 1;
	237
	238	/@access fileId@/
	239	INTCOMPARERETURN (f1->fid, f2->fid);
	240	/@noaccess fileId@/
	241
f4ec8018	242
f4ec8018	243	/* drl 8-11-01 fix what I think is a bug
b7e84605	244	lineno should more important than column number*/
	245
	246	INTCOMPARERETURN (f1->lineno, f2->lineno);
f4ec8018	247	INTCOMPARERETURN (f1->column, f2->column);
f4ec8018	248
616915dd	249	return 0;
	250	}
	251
	252	bool
	253	fileloc_withinLines (fileloc f1, fileloc f2, int n)
	254	{
	255
	256	return (fileloc_isDefined (f1) &&
	257	fileloc_isDefined (f2) &&
	258	((f2->lineno <= f1->lineno + n)
	259	&& (f2->lineno >= f1->lineno)
	260	&& fileloc_sameFile (f1, f2)));
	261	}
	262
	263	bool
	264	fileloc_lessthan (fileloc f1, fileloc f2)
	265	{
	266	/@access fileId/
	267	return ((fileloc_isDefined (f1) && fileloc_isDefined (f2))
	268	&& ((f1->fid < f2->fid)
	269	\|\| ((f1->fid == f2->fid)
	270	&& ((f1->lineno < f2->lineno)
	271	\|\| ((f1->lineno == f2->lineno)
	272	&& (f1->column < f2->column))))));
	273	/@noaccess fileId/
	274	}
	275
	276	/*
	277	** returns true if f1 and f2 are different files,
	278	** or f1 is before f2 in same file
	279	*/
	280
	281	bool
	282	fileloc_notAfter (fileloc f1, fileloc f2)
	283	{
	284	/@access fileId/
	285	return ((fileloc_isDefined (f1) && fileloc_isDefined (f2))
	286	&& ((f1->fid != f2->fid)
	287	\|\| ((f1->lineno < f2->lineno)
	288	\|\| ((f1->lineno == f2->lineno)
	289	&& (f1->column <= f2->column)))));
	290	/@noaccess fileId@/
	291	}
	292
	293	# ifndef NOLCL
	294	bool
	295	fileloc_isStandardLibrary (fileloc f)
	296	{
	297	cstring s = fileloc_getBase (f);
	298
	299	return (cstring_equalLit (s, LLSTDLIBS_NAME)
	300	\|\| cstring_equalLit (s, LLSTRICTLIBS_NAME)
	301	\|\| cstring_equalLit (s, LLUNIXLIBS_NAME)
	302	\|\| cstring_equalLit (s, LLUNIXSTRICTLIBS_NAME)
	303	\|\| cstring_equalLit (s, LLPOSIXSTRICTLIBS_NAME)
	304	\|\| cstring_equalLit (s, LLPOSIXLIBS_NAME));
	305	}
	306	# endif
	307
28bf4b0b	308	bool
	309	fileloc_sameFileAndLine (fileloc f1, fileloc f2)
	310	{
	311	return (fileloc_sameFile (f1, f2)
	312	&& (fileloc_isDefined (f1) && fileloc_isDefined (f2)
	313	&& f1->lineno == f2->lineno));
	314	}
	315
616915dd	316	bool
	317	fileloc_sameFile (fileloc f1, fileloc f2)
	318	{
	319	if ((fileloc_isUndefined (f1) \|\| (fileloc_isUndefined (f2))
	320	\|\| (fileloc_isLib (f1)) \|\| (fileloc_isLib (f2))))
	321	{
	322	return FALSE;
	323	}
	324	else
	325	{
	326	return (fileId_equal (f1->fid, f2->fid));
	327	}
	328	}
	329
	330	bool
	331	fileloc_sameModule (fileloc f1, fileloc f2)
	332	{
	333	if (fileloc_isUndefined (f1))
	334	{
	335	return (fileloc_isUndefined (f2));
	336	}
	337	else if (fileloc_isUndefined (f2))
	338	{
	339	return (FALSE);
	340	}
	341	else
	342	{
	343	if (fileloc_isBuiltin (f1) \|\| fileloc_isBuiltin (f2)
	344	\|\| fileloc_isExternal (f1) \|\| fileloc_isExternal (f2))
	345	{
	346	return fileloc_sameFile (f1, f2);
	347	}
	348	else
	349	{
	350	cstring s1 = fileloc_getBase (f1);
	351	cstring s2 = fileloc_getBase (f2);
	352
	353	return (cstring_equal (s1, s2));
	354	}
	355	}
	356	}
	357
	358	bool
	359	fileloc_sameBaseFile (fileloc f1, fileloc f2)
	360	{
	361	if (fileloc_isUndefined (f1))
	362	{
	363	return (fileloc_isUndefined (f2));
	364	}
	365	else if (fileloc_isUndefined (f2))
	366	{
	367	return (FALSE);
	368	}
	369	else
	370	{
	371	return (fileId_baseEqual (f1->fid, f2->fid));
	372	}
	373	}
	374
	375	bool fileloc_isSystemFile (fileloc f1)
	376	{
	377	if (fileloc_isDefined (f1)
	378	&& !fileloc_isBuiltin (f1)
	379	&& !fileloc_isExternal (f1))
380	{
381	return (fileTable_isSystemFile (context_fileTable (), f1->fid));
382	}
383
384	return FALSE;
385	}
386
28bf4b0b	387	bool fileloc_isXHFile (fileloc f1)
	388	{
	389	if (fileloc_isDefined (f1)
	390	&& !fileloc_isBuiltin (f1)
	391	&& !fileloc_isExternal (f1))
	392	{
ccf0a4a8	393	DPRINTF (("Fileloc is XH: [%p] %s", f1, fileloc_unparse (f1)));
28bf4b0b	394	return (fileTable_isXHFile (context_fileTable (), f1->fid));
	395	}
	396
	397	return FALSE;
	398	}
	399
616915dd	400	bool
	401	fileloc_almostSameFile (fileloc f1, fileloc f2)
	402	{
	403	if ((fileloc_isUndefined (f1) \|\| (fileloc_isUndefined (f2))
	404	\|\| (fileloc_isLib (f1)) \|\| (fileloc_isLib (f2))))
	405	{
	406	return FALSE;
	407	}
	408	else
	409	{
	410	if (fileId_baseEqual (f1->fid, f2->fid))
	411	{
	412	return TRUE;
	413	}
	414	else if (fileTable_isSystemFile (context_fileTable (), f1->fid)
	415	\|\| fileTable_isSystemFile (context_fileTable (), f2->fid))
	416	{
	417	return TRUE;
	418	}
	419	else if (fileTable_isSpecialFile (context_fileTable (), f1->fid)
	420	\|\| fileTable_isSpecialFile (context_fileTable (), f2->fid))
	421	{
	422	return (cstring_equal (fileloc_getBase (f1),
	423	fileloc_getBase (f2)));
	424	}
	425	else
	426	{
	427	return FALSE;
	428	}
	429	}
	430	}
	431
	432	# ifndef NOLCL
	433	/@only@/ fileloc
	434	fileloc_fromTok (ltoken t)
	435	{
	436	cstring fname = ltoken_fileName (t);
	437	fileId fid = fileTable_lookup (context_fileTable (), fname);
	438	fileloc fl;
	439
	440	if (!fileId_isValid (fid))
	441	{
	442	fid = fileTable_addLCLFile (context_fileTable (), fname);
	443	}
	444
	445	fl = fileloc_create (fid, (int) ltoken_getLine (t), (int) ltoken_getCol (t));
	446
	447	return (fl);
	448	}
	449	# endif
	450
	451	/@only@/ fileloc
	452	fileloc_createLib (cstring ln)
	453	{
	454	flkind fk = FL_LIB;
	455	fileId fid = fileTable_lookup (context_fileTable (), ln);
	456
	457	if (!fileId_isValid (fid))
	458	{
	459	fid = fileTable_addLibraryFile (context_fileTable (), ln);
	460	}
	461
68de3f33	462	if (cstring_equalPrefix (ln, cstring_makeLiteralTemp (SYSTEM_LIBDIR)))
616915dd	463	{
	464	fk = FL_STDLIB;
	465	}
	466
	467	return (fileloc_createPrim (fk, fid, 0, 0));
	468	}
	469
	470	fileloc fileloc_createRc (cstring name)
	471	{
	472	fileId fid = fileTable_addFile (context_fileTable (), name);
	473
	474	return (fileloc_createPrim (FL_RC, fid, 0, 0));
	475	}
	476
	477	fileloc fileloc_createExternal (void)
	478	{
	479	/@i@/ return (fileloc_getExternal ());
	480	}
	481
	482	fileloc fileloc_getExternal (void)
	483	{
	484	static /@owned@/ fileloc res = fileloc_undefined;
	485
	486	if (res == fileloc_undefined)
	487	{
	488	res = fileloc_createPrim (FL_EXTERNAL, fileId_invalid, 0, 0);
	489	}
	490
	491	return res;
	492	}
	493
	494	fileloc fileloc_observeBuiltin ()
	495	{
	496	/@-onlytrans@/ return (fileloc_getBuiltin ()); /@=onlytrans@/
	497	}
	498
	499	fileloc fileloc_getBuiltin ()
	500	{
	501	static /@owned@/ fileloc res = fileloc_undefined;
	502
	503	if (res == fileloc_undefined)
	504	{
	505	res = fileloc_createPrim (FL_BUILTIN, fileId_invalid, 0, 0);
	506	}
	507
	508	return res;
	509	}
	510
	511	fileloc
	512	fileloc_makePreproc (fileloc loc)
	513	{
	514	if (fileloc_isDefined (loc))
	515	{
	516	return (fileloc_createPrim (FL_PREPROC, loc->fid,
	517	loc->lineno, loc->column));
	518	}
	519
	520	return (fileloc_createPrim (FL_PREPROC, fileId_invalid, 0, 0));
	521	}
	522
	523	fileloc
	524	fileloc_makePreprocPrevious (fileloc loc)
	525	{
	526	if (fileloc_isDefined (loc))
527	{
528	if (loc->lineno > 1)
529	{
530	return (fileloc_createPrim (FL_PREPROC, loc->fid,
531	loc->lineno - 1, 0));
532	}
533	else
534	{
535	return (fileloc_createPrim (FL_PREPROC, loc->fid,
536	loc->lineno, 0));
537	}
538	}
539
540	return (fileloc_createPrim (FL_PREPROC, fileId_invalid, 0, 0));
541	}
542
543	/@only@/ fileloc
544	fileloc_createBuiltin ()
545	{
546	return (fileloc_createPrim (FL_BUILTIN, fileId_invalid, 0, 0));
547	}
548
549	# ifndef NOLCL
550	/@only@/ fileloc
551	fileloc_createImport (cstring fname, int lineno)
552	{
553	fileId fid = fileTable_lookup (context_fileTable (), fname);
554
555	if (!fileId_isValid (fid))
556	{
557	fid = fileTable_addImportFile (context_fileTable (), fname);
558	}
559
560	return (fileloc_createPrim (FL_IMPORT, fid, lineno, 0));
561	}
562	# endif
563
564	static /@only@/ fileloc
565	fileloc_createPrim (flkind kind, fileId fid, int line, int col)
566	{
567	fileloc f = (fileloc) dmalloc (sizeof (*f));
568
569	f->kind = kind;
570	f->fid = fid;
571	f->lineno = line;
572	f->column = col;
28bf4b0b	573
ccf0a4a8	574	DPRINTF (("Fileloc create: [%p] %s", f, fileloc_unparse (f)));
616915dd	575	return (f);
	576	}
	577
	578	# ifndef NOLCL
	579	/@only@/ fileloc
	580	fileloc_createSpec (fileId fid, int line, int col)
	581	{
	582	return (fileloc_createPrim (FL_SPEC, fid, line, col));
	583	}
	584	# endif
	585
	586	fileloc fileloc_create (fileId fid, int line, int col)
	587	{
	588	return (fileloc_createPrim (fileId_kind (fid), fid, line, col));
	589	}
	590
	591	/@observer@/ cstring
	592	fileloc_filename (fileloc f)
	593	{
4dd72714	594	return (fileloc_isDefined (f) ? fileTable_rootFileName (f->fid) : cstring_makeLiteralTemp ("<unknown>"));
53a89507	595	}
	596
	597	/@only@/ cstring fileloc_outputFilename (fileloc f)
	598	{
	599	if (fileloc_isDefined (f))
	600	{
4dd72714	601	return osd_outputPath (fileTable_rootFileName (f->fid));
53a89507	602	}
	603	else
	604	{
	605	return cstring_makeLiteral ("<unknown>");
	606	}
616915dd	607	}
	608
	609	cstring
	610	fileloc_unparseFilename (fileloc f)
	611	{
	612	if (fileloc_isDefined (f))
	613	{
	614	switch (f->kind)
	615	{
	616	case FL_LIB:
53a89507	617	return (message ("load file %q", fileloc_outputFilename (f)));
616915dd	618	case FL_BUILTIN:
	619	return (cstring_makeLiteral ("# builtin #"));
	620	case FL_IMPORT:
53a89507	621	return (message ("import file %q", fileloc_outputFilename (f)));
616915dd	622	case FL_EXTERNAL:
	623	return (cstring_makeLiteral ("<external>"));
	624	default:
53a89507	625	return (fileloc_outputFilename (f));
616915dd	626	}
	627	}
	628	return cstring_undefined;
	629	}
	630
	631	int
	632	fileloc_lineno (fileloc f)
	633	{
	634	return (fileloc_isDefined (f) ? f->lineno : -1);
	635	}
	636
	637	int
	638	fileloc_column (fileloc f)
	639	{
	640	return (fileloc_isDefined (f) ? f->column : -1);
	641	}
	642
	643	/@only@/ cstring
	644	fileloc_unparse (fileloc f)
	645	{
	646	bool parenFormat = context_getFlag (FLG_PARENFILEFORMAT);
	647
	648	if (fileloc_isDefined (f))
	649	{
28bf4b0b	650	switch (f->kind)
616915dd	651	{
616915dd	652	case FL_BUILTIN:
	653	return (cstring_makeLiteral ("Command Line"));
	654	case FL_IMPORT:
	655	if (parenFormat)
	656	{
53a89507	657	return (message ("import file %q(%d)", fileloc_outputFilename (f), f->lineno));
616915dd	658	}
	659	else
	660	{
53a89507	661	return (message ("import file %q:%d", fileloc_outputFilename (f), f->lineno));
616915dd	662	}
	663	case FL_PREPROC:
	664	if (parenFormat)
	665	{
53a89507	666	return (message ("%q(%d)", fileloc_outputFilename (f), f->lineno));
616915dd	667	}
	668	else
	669	{
53a89507	670	return (message ("%q:%d", fileloc_outputFilename (f), f->lineno));
616915dd	671	}
	672	case FL_EXTERNAL:
	673	return (cstring_makeLiteral ("<external>"));
	674	default:
28bf4b0b	675	{
28bf4b0b	676	cstring fname;
53a89507	677
28bf4b0b	678	if (f->kind == FL_LIB)
28bf4b0b	679	{
53a89507	680	fname = message ("load file %q", fileloc_outputFilename (f));
28bf4b0b	681	}
	682	else
	683	{
53a89507	684	fname = fileloc_outputFilename (f);
28bf4b0b	685	}
	686
	687	if (context_getFlag (FLG_SHOWCOL))
	688	{
	689	if (fileloc_linenoDefined (f))
	690	{
	691	if (fileloc_columnDefined (f))
	692	{
	693	if (parenFormat)
	694	{
53a89507	695	return (message ("%q(%d,%d)", fname, f->lineno, f->column));
28bf4b0b	696	}
	697	else
	698	{
53a89507	699	return (message ("%q:%d:%d", fname, f->lineno, f->column));
28bf4b0b	700	}
	701	}
	702	else
	703	{
	704	if (parenFormat)
	705	{
53a89507	706	return (message ("%q(%d)", fname, f->lineno));
28bf4b0b	707	}
	708	else
	709	{
53a89507	710	return (message ("%q:%d", fname, f->lineno));
28bf4b0b	711	}
	712	}
	713	}
53a89507	714
53a89507	715	return fname;
28bf4b0b	716	}
	717	else if (fileloc_linenoDefined (f))
	718	{
	719	if (parenFormat)
	720	{
53a89507	721	return (message ("%q(%d)", fname, f->lineno));
28bf4b0b	722	}
	723	else
	724	{
53a89507	725	return (message ("%q:%d", fname, f->lineno));
28bf4b0b	726	}
	727	}
	728	else
	729	{
53a89507	730	return fname;
28bf4b0b	731	}
28bf4b0b	732	}
616915dd	733	}
616915dd	734	}
28bf4b0b	735
616915dd	736	return (cstring_makeLiteral ("< Location unknown >"));
	737	}
	738
	739	/@only@/ cstring
	740	fileloc_unparseRaw (cstring fname, int lineno)
	741	{
	742	bool parenFormat = context_getFlag (FLG_PARENFILEFORMAT);
	743
	744	if (parenFormat)
	745	{
53a89507	746	return (message ("%q(%d)", osd_outputPath (fname), lineno));
616915dd	747	}
	748	else
	749	{
53a89507	750	return (message ("%q:%d", osd_outputPath (fname), lineno));
616915dd	751	}
	752	}
	753
	754	/@only@/ cstring
	755	fileloc_unparseRawCol (cstring fname, int lineno, int col)
	756	{
	757	if (context_getFlag (FLG_SHOWCOL))
	758	{
	759	bool parenFormat = context_getFlag (FLG_PARENFILEFORMAT);
	760
	761	if (parenFormat)
	762	{
53a89507	763	return (message ("%q(%d,%d)", osd_outputPath (fname), lineno, col));
616915dd	764	}
	765	else
	766	{
53a89507	767	return (message ("%q:%d:%d", osd_outputPath (fname), lineno, col));
616915dd	768	}
	769	}
	770	else
	771	{
	772	return fileloc_unparseRaw (fname, lineno);
	773	}
	774	}
	775
	776	bool fileloc_isSpecialFile (fileloc f)
	777	{
	778	if (fileloc_isDefined (f)
	779	&& fileId_isValid (f->fid))
	780	{
	781	return (fileTable_isSpecialFile (context_fileTable (), f->fid));
	782	}
	783	else
	784	{
	785	return FALSE;
	786	}
	787	}
	788
	789	bool fileloc_isHeader (fileloc f)
	790	{
	791	/* returns true if is not a .c file */
	792
	793	return (fileloc_isDefined (f) && fileId_isValid (f->fid)
	794	&& fileId_isHeader (f->fid));
	795	}
	796
	797	bool fileloc_isSpec (fileloc f)
	798	{
	799	return (fileloc_isDefined (f) &&
	800	(f->kind == FL_LIB \|\| f->kind == FL_STDLIB \|\| f->kind == FL_SPEC));
	801	}
	802
	803	bool fileloc_isRealSpec (fileloc f)
	804	{
	805	return (fileloc_isDefined (f) && (f->kind == FL_SPEC));
	806	}
	807
616915dd	808	bool fileloc_isLib (fileloc f)
	809	{
	810	return (fileloc_isDefined (f)
	811	&& (f->kind == FL_LIB \|\| f->kind == FL_STDHDR \|\| f->kind == FL_STDLIB));
	812	}
	813
	814	bool fileloc_isStandardLib (fileloc f)
	815	{
	816	return (fileloc_isDefined (f) && f->kind == FL_STDLIB);
	817	}
	818
	819	/@only@/ cstring fileloc_unparseDirect (fileloc fl)
	820	{
	821	if (fileloc_isDefined (fl))
	822	{
	823	return (message ("%d:%d:%d",
	824	/@access fileId@/ (int) fl->fid, /@noaccess fileId@/
	825	fl->lineno, fl->column));
	826	}
	827	else
	828	{
	829	return (cstring_makeLiteral ("<undef>"));
	830	}
	831	}
	832
	833	bool fileloc_isUser (fileloc f)
	834	{
	835	return (fileloc_isDefined (f)
	836	&& f->kind == FL_NORMAL);
	837	}
	838
	839
	840
	841