Transfer of OSVVM utility library to IEEE Open Source servers

f61780d4 · Jim Lewis · 9543dfaf · f61780d4
Commit f61780d4 authored Jul 13, 2020 by Jim Lewis
--- a/AlertLogPkg.vhd
+++ b/AlertLogPkg.vhd
+--
+--  File Name:         AlertLogPkg.vhd
+--  Design Unit Name:  AlertLogPkg
+--  Revision:          STANDARD VERSION
+--
+--  Maintainer:        Jim Lewis      email:  jim@synthworks.com
+--  Contributor(s):
+--     Jim Lewis      jim@synthworks.com
+--     Rob Gaddi      Highland Technology.    Inspired SetAlertLogPrefix / Suffix
+--
+--
+--  Description:
+--        Alert handling and log filtering (verbosity control)
+--        Alert handling provides a method to count failures, errors, and warnings
+--          To accumlate counts, a data structure is created in a shared variable
+--          It is of type AlertLogStructPType which is defined in AlertLogBasePkg
+--        Log filtering provides verbosity control for logs (display or do not display)
+--        AlertLogPkg provides a simplified interface to the shared variable
+--
+--
+--  Developed for:
+--        SynthWorks Design Inc.
+--        VHDL Training Classes
+--        11898 SW 128th Ave.  Tigard, Or  97223
+--        http://www.SynthWorks.com
+--
+--  Revision History:
+--    Date      Version    Description
+--    01/2015   2015.01    Initial revision
+--    03/2015   2015.03    Added:  AlertIfEqual, AlertIfNotEqual, AlertIfDiff, PathTail,
+--                         ReportNonZeroAlerts, ReadLogEnables
+--    05/2015   2015.06    Added IncAlertCount, AffirmIf
+--    07/2015   2016.01    Fixed AlertLogID issue with > 32 IDs
+--    02/2016   2016.02    Fixed IsLogEnableType (for PASSED), AffirmIf (to pass AlertLevel)
+--                         Created LocalInitialize
+--    05/2017   2017.05    AffirmIfEqual, AffirmIfDiff,
+--                         GetAffirmCount (deprecates GetAffirmCheckCount), IncAffirmCount (deprecates IncAffirmCheckCount),
+--                         IsAlertEnabled (alias), IsLogEnabled (alias)
+--    04/2018   2018.04    Fix to PathTail.  Prep to change AlertLogIDType to a type.
+--    10/2018   2018.10    Added pragmas to allow alerts, logs, and affirmations in RTL code
+--                         Added local variable to mirror top level ErrorCount and display in simulator
+--                         Added prefix and suffix
+--                         Debug printing with number of errors as prefix
+--    01/2020   2020.01    Updated Licenses to Apache
+--    05/2020   2020.05    Added internal variables AlertCount (W, E, F) and ErrorCount (integer)  
+--                         that hold the error state.   These can be displayed in wave windows
+--                         in simulation to track number of errors. 
+--                         Calls to std.env.stop now return ErrorCount
+--                         Updated calls to check for valid AlertLogIDs
+--                         Added affirmation count for each level.
+--                           Turn off reporting with SetAlertLogOptions (PrintAffirmations => TRUE) ;
+--                         Disabled Alerts now handled in separate bins and reported 
+--                         separately.  Turn off reporting with SetAlertLogOptions (PrintDisabledAlerts => TRUE) ;
+--
+--
+--  This file is part of OSVVM.
+--  
+--  Copyright (c) 2015 - 2020 by SynthWorks Design Inc.  
+--  
+--  Licensed under the Apache License, Version 2.0 (the "License");
+--  you may not use this file except in compliance with the License.
+--  You may obtain a copy of the License at
+--  
+--      https://www.apache.org/licenses/LICENSE-2.0
+--  
+--  Unless required by applicable law or agreed to in writing, software
+--  distributed under the License is distributed on an "AS IS" BASIS,
+--  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+--  See the License for the specific language governing permissions and
+--  limitations under the License.
+--  
+
+
+use std.textio.all ;
+use work.OsvvmGlobalPkg.all ;
+use work.TranscriptPkg.all ;
+use work.TextUtilPkg.all ;
+
+library IEEE ;
+use ieee.std_logic_1164.all ;
+use ieee.numeric_std.all ;
+
+package AlertLogPkg is
+
+--  type     AlertLogIDType       is range integer'low to integer'high ; -- next revsion
+  subtype     AlertLogIDType       is integer ;
+  type     AlertLogIDVectorType is array (integer range <>) of AlertLogIDType ;
+  type     AlertType        is (FAILURE, ERROR, WARNING) ;  -- NEVER
+  subtype  AlertIndexType   is AlertType range FAILURE to WARNING ;
+  type     AlertCountType   is array (AlertIndexType) of integer ;
+  type     AlertEnableType  is array(AlertIndexType) of boolean ;
+  type     LogType          is (ALWAYS, DEBUG, FINAL, INFO, PASSED) ;  -- NEVER  -- See function IsLogEnableType
+  subtype  LogIndexType     is LogType range DEBUG to PASSED ;
+  type     LogEnableType    is array (LogIndexType) of boolean ;
+
+  constant  ALERTLOG_BASE_ID               : AlertLogIDType := 0 ;  -- Careful as some code may assume this is 0.
+  constant  ALERTLOG_DEFAULT_ID            : AlertLogIDType := 1 ;
+  constant  ALERT_DEFAULT_ID               : AlertLogIDType := ALERTLOG_DEFAULT_ID ;
+  constant  LOG_DEFAULT_ID                 : AlertLogIDType := ALERTLOG_DEFAULT_ID ;
+  constant  OSVVM_ALERTLOG_ID              : AlertLogIDType := 2 ;
+  constant  OSVVM_SCOREBOARD_ALERTLOG_ID   : AlertLogIDType := OSVVM_ALERTLOG_ID ;
+  -- NUM_PREDEFINED_AL_IDS intended to be local, but depends on others
+  -- constant  NUM_PREDEFINED_AL_IDS          : AlertLogIDType := OSVVM_SCOREBOARD_ALERTLOG_ID - ALERTLOG_BASE_ID ;  -- Not including base
+  constant  ALERTLOG_ID_NOT_FOUND          : AlertLogIDType := -1 ;  -- alternately integer'right
+  constant  ALERTLOG_ID_NOT_ASSIGNED       : AlertLogIDType := -1 ;
+  constant  MIN_NUM_AL_IDS                 : AlertLogIDType := 32 ; -- Number IDs initially allocated
+
+  alias AlertLogOptionsType is work.OsvvmGlobalPkg.OsvvmOptionsType ;
+
+  ------------------------------------------------------------
+  --  Alert always goes to the transcript file
+  procedure Alert(
+    AlertLogID   : AlertLogIDType ;
+    Message      : string ;
+    Level        : AlertType := ERROR
+  ) ;
+  procedure Alert( Message : string ; Level : AlertType := ERROR ) ;
+
+  ------------------------------------------------------------
+  procedure IncAlertCount(   -- A silent form of alert
+    AlertLogID   : AlertLogIDType ;
+    Level        : AlertType := ERROR
+  ) ;
+  procedure IncAlertCount( Level : AlertType := ERROR ) ;
+
+  ------------------------------------------------------------
+  -- Similar to assert, except condition is positive
+  procedure AlertIf( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIf( condition : boolean ; Message : string ; Level : AlertType := ERROR ) ;
+  impure function  AlertIf( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean ;
+  impure function  AlertIf( condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean ;
+
+  ------------------------------------------------------------
+  -- Direct replacement for assert
+  procedure AlertIfNot( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNot( condition : boolean ; Message : string ; Level : AlertType := ERROR ) ;
+  impure function  AlertIfNot( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean ;
+  impure function  AlertIfNot( condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean ;
+
+  ------------------------------------------------------------
+  -- overloading for common functionality
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : std_logic ;         Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : std_logic_vector ;  Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : unsigned ;          Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : signed ;            Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : integer ;           Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : real ;              Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : character ;         Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : string ;            Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( AlertLogID : AlertLogIDType ;  L, R : time ;              Message : string ; Level : AlertType := ERROR )  ;
+
+  procedure AlertIfEqual( L, R : std_logic ;        Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( L, R : std_logic_vector ; Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( L, R : unsigned ;         Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( L, R : signed ;           Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( L, R : integer ;          Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( L, R : real ;             Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( L, R : character ;        Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( L, R : string ;           Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfEqual( L, R : time ;             Message : string ; Level : AlertType := ERROR )  ;
+
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : std_logic ;        Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : std_logic_vector ; Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : unsigned ;         Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : signed ;           Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : integer ;          Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : real ;             Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : character ;        Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : string ;           Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ;  L, R : time ;             Message : string ; Level : AlertType := ERROR )  ;
+
+  procedure AlertIfNotEqual( L, R : std_logic ;        Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( L, R : std_logic_vector ; Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( L, R : unsigned ;         Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( L, R : signed ;           Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( L, R : integer ;          Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( L, R : real ;             Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( L, R : character ;        Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( L, R : string ;           Message : string ; Level : AlertType := ERROR )  ;
+  procedure AlertIfNotEqual( L, R : time ;             Message : string ; Level : AlertType := ERROR )  ;
+
+  ------------------------------------------------------------
+  -- Simple Diff for file comparisons
+  procedure AlertIfDiff (AlertLogID : AlertLogIDType ; Name1, Name2 : string; Message : string := "" ; Level : AlertType := ERROR ) ;
+  procedure AlertIfDiff (Name1, Name2 : string; Message : string := "" ; Level : AlertType := ERROR ) ;
+  procedure AlertIfDiff (AlertLogID : AlertLogIDType ; file File1, File2 : text; Message : string := "" ; Level : AlertType := ERROR ) ;
+  procedure AlertIfDiff (file File1, File2 : text; Message : string := "" ; Level : AlertType := ERROR ) ;
+
+  ------------------------------------------------------------
+  ------------------------------------------------------------
+  ------------------------------------------------------------
+  procedure AffirmIf(
+  ------------------------------------------------------------
+    AlertLogID       : AlertLogIDType ;
+    condition        : boolean ;
+    ReceivedMessage  : string ;
+    ExpectedMessage  : string ;
+    Enable           : boolean  := FALSE   -- override internal enable
+  ) ;
+
+  procedure AffirmIf( condition : boolean ; ReceivedMessage, ExpectedMessage : string ; Enable : boolean := FALSE ) ;
+  impure function AffirmIf( AlertLogID : AlertLogIDType ; condition : boolean ; ReceivedMessage, ExpectedMessage : string ; Enable : boolean := FALSE ) return boolean ;
+  impure function AffirmIf( condition : boolean ; ReceivedMessage, ExpectedMessage : string ; Enable : boolean := FALSE ) return boolean ;
+
+  procedure AffirmIf(
+    AlertLogID   : AlertLogIDType ;
+    condition    : boolean ;
+    Message      : string ;
+    Enable       : boolean := FALSE -- override internal enable
+  ) ;
+
+  procedure AffirmIf(condition : boolean ; Message : string ;  Enable : boolean := FALSE ) ;
+  impure function  AffirmIf( AlertLogID  : AlertLogIDType ; condition : boolean ; Message : string ; Enable : boolean := FALSE ) return boolean ;
+  impure function  AffirmIf( condition : boolean ; Message : string ; Enable : boolean := FALSE ) return boolean ;
+
+  ------------------------------------------------------------
+  procedure AffirmIfNot( AlertLogID : AlertLogIDType ; condition : boolean ; ReceivedMessage, ExpectedMessage : string ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfNot( condition : boolean ; ReceivedMessage, ExpectedMessage : string ; Enable : boolean := FALSE ) ;
+  impure function  AffirmIfNot( AlertLogID  : AlertLogIDType ; condition : boolean ; ReceivedMessage, ExpectedMessage : string ; Enable : boolean := FALSE ) return boolean ;
+  impure function  AffirmIfNot( condition : boolean ; ReceivedMessage, ExpectedMessage : string ; Enable : boolean := FALSE ) return boolean ;
+
+  ------------------------------------------------------------
+  procedure AffirmIfNot( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfNot( condition : boolean ; Message : string ; Enable : boolean := FALSE ) ;
+  impure function  AffirmIfNot( AlertLogID  : AlertLogIDType ; condition : boolean ; Message : string ; Enable : boolean := FALSE ) return boolean ;
+  impure function  AffirmIfNot( condition : boolean ; Message : string ; Enable : boolean := FALSE ) return boolean ;
+
+  ------------------------------------------------------------
+  procedure AffirmPassed( AlertLogID : AlertLogIDType ; Message : string ; Enable : boolean := FALSE ) ;
+  procedure AffirmPassed( Message : string ; Enable : boolean := FALSE ) ;
+  procedure AffirmError( AlertLogID : AlertLogIDType ; Message : string ) ;
+  procedure AffirmError( Message : string ) ;
+
+  ------------------------------------------------------------
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : std_logic ;  Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : std_logic_vector ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : unsigned ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : signed ; Message : string := "" ; Enable : boolean := FALSE );
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : integer ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : real ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : character ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : string ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( AlertLogID : AlertLogIDType ; Received, Expected : time ; Message : string := "" ; Enable : boolean := FALSE ) ;
+
+  -- Without AlertLogID
+  ------------------------------------------------------------
+  procedure AffirmIfEqual( Received, Expected : std_logic ;  Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( Received, Expected : std_logic_vector ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( Received, Expected : unsigned ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( Received, Expected : signed ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( Received, Expected : integer ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( Received, Expected : real ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( Received, Expected : character ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( Received, Expected : string ; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfEqual( Received, Expected : time ; Message : string := "" ; Enable : boolean := FALSE ) ;
+
+  ------------------------------------------------------------
+  procedure AffirmIfDiff (AlertLogID : AlertLogIDType ; Name1, Name2 : string; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfDiff (Name1, Name2 : string; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfDiff (AlertLogID : AlertLogIDType ; file File1, File2 : text; Message : string := "" ; Enable : boolean := FALSE ) ;
+  procedure AffirmIfDiff (file File1, File2 : text; Message : string := "" ; Enable : boolean := FALSE ) ;
+
+  ------------------------------------------------------------
+  procedure SetAlertLogJustify (Enable : boolean := TRUE) ;
+  procedure ReportAlerts ( Name : String ; AlertCount : AlertCountType ) ;
+  procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (others => 0) ) ;
+  procedure ReportNonZeroAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (others => 0) ) ;
+  procedure ClearAlerts ;
+  procedure ClearAlertStopCounts ;
+  procedure ClearAlertCounts ;
+  function "ABS" (L : AlertCountType) return AlertCountType ;
+  function "+" (L, R : AlertCountType) return AlertCountType ;
+  function "-" (L, R : AlertCountType) return AlertCountType ;
+  function "-" (R : AlertCountType) return AlertCountType ;
+  impure function SumAlertCount(AlertCount: AlertCountType) return integer ;
+  impure function GetAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertCountType ;
+  impure function GetAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return integer ;
+  impure function GetEnabledAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertCountType ;
+  impure function GetEnabledAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return integer ;
+  impure function GetDisabledAlertCount return AlertCountType ;
+  impure function GetDisabledAlertCount return integer ;
+  impure function GetDisabledAlertCount(AlertLogID: AlertLogIDType) return AlertCountType ;
+  impure function GetDisabledAlertCount(AlertLogID: AlertLogIDType) return integer ;
+
+  ------------------------------------------------------------
+  --  log filtering for verbosity control, optionally has a separate file parameter
+  procedure Log(
+    AlertLogID   : AlertLogIDType ;
+    Message      : string ;
+    Level        : LogType := ALWAYS ;
+    Enable       : boolean := FALSE    -- override internal enable
+  ) ;
+  procedure Log( Message : string ; Level : LogType := ALWAYS ; Enable : boolean := FALSE) ;
+
+  ------------------------------------------------------------
+  -- Alert Enables
+  procedure SetAlertEnable(Level : AlertType ;  Enable : boolean) ;
+  procedure SetAlertEnable(AlertLogID : AlertLogIDType ;  Level : AlertType ;  Enable : boolean ; DescendHierarchy : boolean := TRUE) ;
+  impure function GetAlertEnable(AlertLogID : AlertLogIDType ;  Level : AlertType) return boolean ;
+  impure function GetAlertEnable(Level : AlertType) return boolean ;
+  alias IsAlertEnabled is GetAlertEnable[AlertLogIDType, AlertType return boolean] ;
+  alias IsAlertEnabled is GetAlertEnable[AlertType return boolean] ;
+
+  -- Log Enables
+  procedure SetLogEnable(Level : LogType ;  Enable : boolean) ;
+  procedure SetLogEnable(AlertLogID : AlertLogIDType ;  Level : LogType ;  Enable : boolean ; DescendHierarchy : boolean := TRUE) ;
+  impure function GetLogEnable(AlertLogID : AlertLogIDType ;  Level : LogType) return boolean ;
+  impure function GetLogEnable(Level : LogType) return boolean ;
+  alias IsLogEnabled is GetLogEnable [AlertLogIDType, LogType return boolean] ;  -- same as GetLogEnable
+  alias IsLogEnabled is GetLogEnable [LogType return boolean] ;  -- same as GetLogEnable
+
+  procedure ReportLogEnables ;
+
+  procedure SetAlertLogName(Name : string ) ;
+  -- synthesis translate_off
+  impure function GetAlertLogName(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return string ;
+  -- synthesis translate_on
+  procedure DeallocateAlertLogStruct ;
+  procedure InitializeAlertLogStruct ;
+  impure function FindAlertLogID(Name : string ) return AlertLogIDType ;
+  impure function FindAlertLogID(Name : string ; ParentID : AlertLogIDType) return AlertLogIDType ;
+  impure function GetAlertLogID(Name : string ; ParentID : AlertLogIDType := ALERTLOG_BASE_ID ; CreateHierarchy : Boolean := TRUE) return AlertLogIDType ;
+  impure function GetAlertLogParentID(AlertLogID : AlertLogIDType) return AlertLogIDType ;
+  procedure SetAlertLogPrefix(AlertLogID : AlertLogIDType; Name : string ) ;
+  procedure UnSetAlertLogPrefix(AlertLogID : AlertLogIDType) ;
+  -- synthesis translate_off
+  impure function GetAlertLogPrefix(AlertLogID : AlertLogIDType) return string ;
+  -- synthesis translate_on
+  procedure SetAlertLogSuffix(AlertLogID : AlertLogIDType; Name : string ) ;
+  procedure UnSetAlertLogSuffix(AlertLogID : AlertLogIDType) ;
+  -- synthesis translate_off
+  impure function GetAlertLogSuffix(AlertLogID : AlertLogIDType) return string ;
+  -- synthesis translate_on
+
+  ------------------------------------------------------------
+  -- Accessor Methods
+  procedure SetGlobalAlertEnable (A : boolean := TRUE) ;
+  impure function SetGlobalAlertEnable (A : boolean := TRUE) return boolean ;
+  impure function GetGlobalAlertEnable return boolean ;
+  procedure IncAffirmCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) ;
+  impure function GetAffirmCount return natural ;
+  procedure IncAffirmPassedCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) ;
+  impure function GetAffirmPassedCount return natural ;
+
+  procedure SetAlertStopCount(AlertLogID : AlertLogIDType ;  Level : AlertType ;  Count : integer) ;
+  procedure SetAlertStopCount(Level : AlertType ;  Count : integer) ;
+  impure function GetAlertStopCount(AlertLogID : AlertLogIDType ;  Level : AlertType) return integer ;
+  impure function GetAlertStopCount(Level : AlertType) return integer ;
+
+  ------------------------------------------------------------
+  procedure SetAlertLogOptions (
+    FailOnWarning         : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    FailOnDisabledErrors  : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    ReportHierarchy       : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    WriteAlertErrorCount  : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    WriteAlertLevel       : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    WriteAlertName        : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    WriteAlertTime        : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    WriteLogErrorCount    : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    WriteLogLevel         : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    WriteLogName          : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    WriteLogTime          : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    PrintPassed           : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    PrintAffirmations     : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    PrintDisabledAlerts   : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+    AlertPrefix           : string := OSVVM_STRING_INIT_PARM_DETECT ;
+    LogPrefix             : string := OSVVM_STRING_INIT_PARM_DETECT ;
+    ReportPrefix          : string := OSVVM_STRING_INIT_PARM_DETECT ;
+    DoneName              : string := OSVVM_STRING_INIT_PARM_DETECT ;
+    PassName              : string := OSVVM_STRING_INIT_PARM_DETECT ;
+    FailName              : string := OSVVM_STRING_INIT_PARM_DETECT
+  ) ;
+
+  procedure ReportAlertLogOptions ;
+
+
+  -- synthesis translate_off
+
+  impure function GetAlertLogFailOnWarning        return AlertLogOptionsType ;
+  impure function GetAlertLogFailOnDisabledErrors return AlertLogOptionsType ;
+  impure function GetAlertLogReportHierarchy      return AlertLogOptionsType ;
+  impure function GetAlertLogFoundReportHier      return boolean ;
+  impure function GetAlertLogFoundAlertHier       return boolean ;
+  impure function GetAlertLogWriteAlertErrorCount return AlertLogOptionsType ;
+  impure function GetAlertLogWriteAlertLevel      return AlertLogOptionsType ;
+  impure function GetAlertLogWriteAlertName       return AlertLogOptionsType ;
+  impure function GetAlertLogWriteAlertTime       return AlertLogOptionsType ;
+  impure function GetAlertLogWriteLogErrorCount   return AlertLogOptionsType ;
+  impure function GetAlertLogWriteLogLevel        return AlertLogOptionsType ;
+  impure function GetAlertLogWriteLogName         return AlertLogOptionsType ;
+  impure function GetAlertLogWriteLogTime         return AlertLogOptionsType ;
+  impure function GetAlertLogPrintPassed          return AlertLogOptionsType ;
+  impure function GetAlertLogPrintAffirmations    return AlertLogOptionsType ;
+  impure function GetAlertLogPrintDisabledAlerts  return AlertLogOptionsType ;
+  
+  impure function GetAlertLogAlertPrefix          return string ;
+  impure function GetAlertLogLogPrefix            return string ;
+
+  impure function GetAlertLogReportPrefix         return string ;
+  impure function GetAlertLogDoneName             return string ;
+  impure function GetAlertLogPassName             return string ;
+  impure function GetAlertLogFailName             return string ;
+
+  -- File Reading Utilities
+  function IsLogEnableType (Name : String) return boolean ;
+  procedure ReadLogEnables (file AlertLogInitFile : text) ;
+  procedure ReadLogEnables (FileName : string) ;
+
+  -- String Helper Functions -- This should be in a more general string package
+  function PathTail (A : string) return string ;
+
+
+  -- synthesis translate_on
+
+
+  --  ------------------------------------------------------------
+  -- Deprecated
+  --
+
+  -- deprecated
+  procedure AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR )  ;
+  impure function  AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean ;
+
+  -- deprecated
+  procedure AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR )  ;
+  impure function  AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean ;
+
+  -- deprecated
+  procedure AffirmIf(
+    AlertLogID   : AlertLogIDType ;
+    condition    : boolean ;
+    Message      : string ;
+    LogLevel     : LogType  ;  -- := PASSED
+    AlertLevel   : AlertType := ERROR
+  )  ;
+  procedure AffirmIf( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; AlertLevel : AlertType ) ;
+  procedure AffirmIf(condition : boolean ; Message : string ;  LogLevel : LogType  ; AlertLevel : AlertType := ERROR) ;
+  procedure AffirmIf(condition : boolean ; Message : string ;  AlertLevel : AlertType ) ;
+
+  alias IncAffirmCheckCount is IncAffirmCount [AlertLogIDType] ;
+  alias GetAffirmCheckCount is GetAffirmCount [return natural] ;
+  alias IsLoggingEnabled is GetLogEnable [AlertLogIDType, LogType return boolean] ;  -- same as IsLogEnabled
+  alias IsLoggingEnabled is GetLogEnable [LogType return boolean] ;  -- same as IsLogEnabled
+
+
+end AlertLogPkg ;
+
+--- ///////////////////////////////////////////////////////////////////////////
+--- ///////////////////////////////////////////////////////////////////////////
+--- ///////////////////////////////////////////////////////////////////////////
+
+use work.NamePkg.all ;
+
+package body AlertLogPkg is
+
+-- synthesis translate_off
+
+  -- instead of justify(to_upper(to_string())), just look up the upper case, left justified values
+  type     AlertNameType is array(AlertType) of string(1 to 7) ;
+  constant ALERT_NAME : AlertNameType := (WARNING => "WARNING", ERROR => "ERROR  ", FAILURE => "FAILURE") ;  -- , NEVER => "NEVER  "
+  type     LogNameType is array(LogType) of string(1 to 7) ;
+  constant LOG_NAME : LogNameType := (DEBUG => "DEBUG  ", FINAL => "FINAL  ", INFO => "INFO   ", ALWAYS => "ALWAYS ", PASSED => "PASSED ") ; -- , NEVER => "NEVER  "
+
+  ------------------------------------------------------------
+  -- Package Local
+  function LeftJustify(A : String;  Amount : integer) return string is
+  ------------------------------------------------------------
+    constant Spaces : string(1 to  maximum(1, Amount)) := (others => ' ') ;
+  begin
+    if A'length >= Amount then
+      return A ;
+    else
+      return A & Spaces(1 to Amount - A'length) ;
+    end if ;
+  end function LeftJustify ;
+
+
+  type AlertLogStructPType is protected
+
+    ------------------------------------------------------------
+    procedure alert (
+    ------------------------------------------------------------
+      AlertLogID   : AlertLogIDType ;
+      message      : string ;
+      level        : AlertType := ERROR
+    ) ;
+
+    ------------------------------------------------------------
+    procedure IncAlertCount ( AlertLogID : AlertLogIDType ; level : AlertType := ERROR ) ;
+    procedure SetJustify (Enable : boolean := TRUE) ;
+    procedure ReportAlerts ( Name : string ; AlertCount : AlertCountType ) ;
+    procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (0,0,0) ; ReportAll : boolean := TRUE ) ;
+    procedure ClearAlerts ;
+    procedure ClearAlertStopCounts ;
+    impure function GetAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertCountType ;
+    impure function GetEnabledAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertCountType ;
+    impure function GetDisabledAlertCount return AlertCountType ;
+    impure function GetDisabledAlertCount(AlertLogID: AlertLogIDType) return AlertCountType ;
+
+    ------------------------------------------------------------
+    procedure log (
+    ------------------------------------------------------------
+      AlertLogID   : AlertLogIDType ;
+      Message      : string ;
+      Level        : LogType := ALWAYS ;
+      Enable       : boolean := FALSE    -- override internal enable
+    ) ;
+
+    ------------------------------------------------------------
+    -- FILE IO Controls
+--    procedure SetTranscriptEnable (A : boolean := TRUE) ;
+--    impure function IsTranscriptEnabled return boolean ;
+--    procedure MirrorTranscript (A : boolean := TRUE) ;
+--    impure function IsTranscriptMirrored return boolean ;
+
+    ------------------------------------------------------------
+    ------------------------------------------------------------
+    -- AlertLog Structure Creation and Interaction Methods
+
+    ------------------------------------------------------------
+    procedure SetAlertLogName(Name : string ) ;
+    procedure SetNumAlertLogIDs (NewNumAlertLogIDs : AlertLogIDType) ;
+    impure function FindAlertLogID(Name : string ) return AlertLogIDType ;
+    impure function FindAlertLogID(Name : string ; ParentID : AlertLogIDType) return AlertLogIDType ;
+    impure function GetAlertLogID(Name : string ; ParentID : AlertLogIDType ; CreateHierarchy : Boolean) return AlertLogIDType ;
+    impure function GetAlertLogParentID(AlertLogID : AlertLogIDType) return AlertLogIDType ;
+    procedure Initialize(NewNumAlertLogIDs : AlertLogIDType := MIN_NUM_AL_IDS) ;
+    procedure Deallocate ;
+    procedure SetAlertLogPrefix(AlertLogID : AlertLogIDType; Name : string ) ;
+    procedure UnSetAlertLogPrefix(AlertLogID : AlertLogIDType) ;
+    impure function GetAlertLogPrefix(AlertLogID : AlertLogIDType) return string ;
+    procedure SetAlertLogSuffix(AlertLogID : AlertLogIDType; Name : string ) ;
+    procedure UnSetAlertLogSuffix(AlertLogID : AlertLogIDType) ;
+    impure function GetAlertLogSuffix(AlertLogID : AlertLogIDType) return string ;
+
+    ------------------------------------------------------------
+    ------------------------------------------------------------
+    -- Accessor Methods
+    ------------------------------------------------------------
+    procedure SetGlobalAlertEnable (A : boolean := TRUE) ;
+    impure function GetAlertLogName(AlertLogID : AlertLogIDType) return string ;
+    impure function GetGlobalAlertEnable return boolean ;
+    procedure IncAffirmCount(AlertLogID : AlertLogIDType) ;
+    impure function GetAffirmCount return natural ;
+    procedure IncAffirmPassedCount(AlertLogID : AlertLogIDType) ;
+    impure function GetAffirmPassedCount return natural ;
+
+    procedure SetAlertStopCount(AlertLogID : AlertLogIDType ;  Level : AlertType ;  Count : integer) ;
+    impure function GetAlertStopCount(AlertLogID : AlertLogIDType ;  Level : AlertType) return integer ;
+
+    procedure SetAlertEnable(Level : AlertType ;  Enable : boolean) ;
+    procedure SetAlertEnable(AlertLogID : AlertLogIDType ;  Level : AlertType ;  Enable : boolean ; DescendHierarchy : boolean := TRUE) ;
+    impure function GetAlertEnable(AlertLogID : AlertLogIDType ;  Level : AlertType) return boolean ;
+
+    procedure SetLogEnable(Level : LogType ;  Enable : boolean) ;
+    procedure SetLogEnable(AlertLogID : AlertLogIDType ;  Level : LogType ;  Enable : boolean ; DescendHierarchy : boolean := TRUE) ;
+    impure function GetLogEnable(AlertLogID : AlertLogIDType ;  Level : LogType) return boolean ;
+
+    procedure ReportLogEnables ;
+
+    ------------------------------------------------------------
+    -- Reporting Accessor
+    procedure SetAlertLogOptions (
+      FailOnWarning         : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      FailOnDisabledErrors  : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      ReportHierarchy       : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      WriteAlertErrorCount  : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      WriteAlertLevel       : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      WriteAlertName        : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      WriteAlertTime        : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      WriteLogErrorCount    : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      WriteLogLevel         : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      WriteLogName          : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      WriteLogTime          : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      PrintPassed           : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      PrintAffirmations     : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;
+      PrintDisabledAlerts   : AlertLogOptionsType := OPT_INIT_PARM_DETECT ;