[splint.git] / src / fileloc.c

/*
** LCLint - annotation-assisted static program checker
** Copyright (C) 1994-2000 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 lclint: lclint-request@cs.virginia.edu
** To report a bug: lclint-bug@cs.virginia.edu
** For more information: http://lclint.cs.virginia.edu
*/
/*
** 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 "lclintMacros.nf"
# include "llbasic.h"
# include "fileIdList.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 = rootFileName (s);
  
  if (isLCLfile (fname))
    {
      return (FL_SPEC);
    }
  else if (cstring_equalPrefix (fname, 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
	{
	  	}
      /*@=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 (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@*/

  INTCOMPARERETURN (f1->column, f2->column);
  INTCOMPARERETURN (f1->lineno, f2->lineno); 

  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_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_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, 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;
  
  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)
	  ? rootFileName (f->fid) : cstring_makeLiteralTemp ("<unknown>"));
}

cstring
fileloc_unparseFilename (fileloc f)
{
  if (fileloc_isDefined (f))
    {
      switch (f->kind)
	{
	case FL_LIB:
	  return (message ("load file %s", fileloc_filename (f)));
	case FL_BUILTIN:
	  return (cstring_makeLiteral ("# builtin #"));
	case FL_IMPORT:
	  return (message ("import file %s", fileloc_filename (f)));
	case FL_EXTERNAL:
	  return (cstring_makeLiteral ("<external>"));
	default: 
	  return (cstring_copy (fileloc_filename (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_LIB:
	  return (message ("load file %s", rootFileName (f->fid)));
	case FL_BUILTIN:
	  return (cstring_makeLiteral ("Command Line"));
	case FL_IMPORT:
	  if (parenFormat)
	    {
	      return (message ("import file %s(%d)", rootFileName (f->fid), f->lineno));
	    }
	  else
	    {
	      return (message ("import file %s:%d", rootFileName (f->fid), f->lineno));
	    }
	case FL_PREPROC:
	  if (parenFormat)
	    {
	      return (message ("%s(%d)", rootFileName (f->fid), f->lineno));
	    }
	  else
	    {
	      return (message ("%s:%d", rootFileName (f->fid), f->lineno));
	    }
	case FL_EXTERNAL:
	  return (cstring_makeLiteral ("<external>"));
	default:
	  if (context_getFlag (FLG_SHOWCOL))
	    {
	      if (fileloc_linenoDefined (f))
		{
		  if (fileloc_columnDefined (f))
		    {
		      if (parenFormat)
			{
			  return (message ("%s(%d,%d)", 
					   rootFileName (f->fid),
					   f->lineno, f->column));
			}
		      else
			{
			  return (message ("%s:%d:%d", 
					   rootFileName (f->fid),
					   f->lineno, f->column));
			}
		    }
		  else
		    {
		      if (parenFormat)
			{
			  return (message ("%s(%d)", rootFileName (f->fid), f->lineno));
			}
		      else
			{
			  return (message ("%s:%d", rootFileName (f->fid), f->lineno));
			}
		    }
		}
	      return (cstring_copy (rootFileName (f->fid)));
	    }
	  else if (fileloc_linenoDefined (f))
	    {
	      if (parenFormat)
		{
		  return (message ("%s(%d)",
				   rootFileName (f->fid), f->lineno));
		}
	      else
		{
		  return (message ("%s:%d", rootFileName (f->fid), f->lineno));
		}
	    }
	  else
	    {
	      return (cstring_copy (rootFileName (f->fid)));
	    }
	}
    }
  return (cstring_makeLiteral ("< Location unknown >"));
}

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

  if (parenFormat)
    {
      return (message ("%s(%d)", fname, lineno));
    }
  else
    {
      return (message ("%s:%d", 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 ("%s(%d,%d)", fname, lineno, col));
	}
      else
	{
	  return (message ("%s:%d:%d", 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_isRealLib (fileloc f)
{
  return (fileloc_isDefined (f) && f->kind == FL_LIB);
}

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