diff --git a/vhdl/osvvm/AlertLogPkg.vhd b/vhdl/osvvm/AlertLogPkg.vhd index c430e1da3..e9800950e 100644 --- a/vhdl/osvvm/AlertLogPkg.vhd +++ b/vhdl/osvvm/AlertLogPkg.vhd @@ -1,7 +1,7 @@ -- -- File Name: AlertLogPkg.vhd -- Design Unit Name: AlertLogPkg --- Revision: STANDARD VERSION, revision 2015.01 +-- Revision: STANDARD VERSION, revision 2015.03 -- -- Maintainer: Jim Lewis email: jim@synthworks.com -- Contributor(s): @@ -26,6 +26,8 @@ -- Revision History: -- Date Version Description -- 01/2015: 2015.01 Initial revision +-- 02/2015 2015.03 Added: AlertIfEqual, AlertIfNotEqual, AlertIfDiff, PathTail, +-- ReportNonZeroAlerts, ReadLogEnables -- -- -- Copyright (c) 2015 by SynthWorks Design Inc. All rights reserved. @@ -53,6 +55,10 @@ use std.textio.all ; use work.OsvvmGlobalPkg.all ; use work.TranscriptPkg.all ; +library IEEE ; +use ieee.std_logic_1164.all ; +use ieee.numeric_std.all ; + package AlertLogPkg is subtype AlertLogIDType is integer ; @@ -64,13 +70,14 @@ package AlertLogPkg is subtype LogIndexType is LogType range DEBUG to INFO ; type LogEnableType is array (LogIndexType) of boolean ; - constant ALERTLOG_BASE_ID : AlertLogIDType := 0 ; - constant ALERT_DEFAULT_ID : AlertLogIDType := 1 ; - constant LOG_DEFAULT_ID : AlertLogIDType := 1 ; - constant ALERTLOG_DEFAULT_ID : AlertLogIDType := ALERT_DEFAULT_ID ; - constant OSVVM_ALERTLOG_ID : AlertLogIDType := 2 ; - constant ALERTLOG_ID_NOT_FOUND : AlertLogIDType := -1 ; -- alternately integer'right - constant MIN_NUM_AL_IDS : AlertLogIDType := 32 ; -- Number IDs initially allocated + constant ALERTLOG_BASE_ID : AlertLogIDType := 0 ; + constant ALERT_DEFAULT_ID : AlertLogIDType := 1 ; + constant LOG_DEFAULT_ID : AlertLogIDType := 1 ; + constant ALERTLOG_DEFAULT_ID : AlertLogIDType := ALERT_DEFAULT_ID ; + constant OSVVM_ALERTLOG_ID : AlertLogIDType := 2 ; + 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 ; @@ -85,22 +92,76 @@ package AlertLogPkg is ------------------------------------------------------------ -- Similar to assert, except condition is positive - procedure AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) ; + procedure AlertIf( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR ) ; procedure AlertIf( condition : boolean ; Message : string ; Level : AlertType := ERROR ) ; - impure function AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean ; + 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 ; + -- 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 ; + ------------------------------------------------------------ -- Direct replacement for assert - procedure AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) ; + procedure AlertIfNot( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR ) ; procedure AlertIfNot( condition : boolean ; Message : string ; Level : AlertType := ERROR ) ; - impure function AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean ; + 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 ; + -- 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 ; + + ------------------------------------------------------------ + -- 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( 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 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( 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 ) ; + ------------------------------------------------------------ + -- 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 SetAlertLogJustify ; - procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (others => 0) ) ; 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 ; function "+" (L, R : AlertCountType) return AlertCountType ; function "-" (L, R : AlertCountType) return AlertCountType ; @@ -122,7 +183,11 @@ package AlertLogPkg is Message : string ; Level : LogType := ALWAYS ) ; - procedure Log( Message : string ; Level : LogType := ALWAYS) ; + procedure Log( Message : string ; Level : LogType := ALWAYS) ; + + impure function IsLoggingEnabled(AlertLogID : AlertLogIDType ; Level : LogType) return boolean ; + impure function IsLoggingEnabled(Level : LogType) return boolean ; + ------------------------------------------------------------ -- Accessor Methods @@ -130,6 +195,7 @@ package AlertLogPkg is procedure InitializeAlertLogStruct ; procedure DeallocateAlertLogStruct ; 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) return AlertLogIDType ; ------------------------------------------------------------ @@ -145,9 +211,9 @@ package AlertLogPkg is procedure SetLogEnable(Level : LogType ; Enable : boolean) ; procedure SetLogEnable(AlertLogID : AlertLogIDType ; Level : LogType ; Enable : boolean ; DescendHierarchy : boolean := TRUE) ; - - impure function IsLoggingEnabled(AlertLogID : AlertLogIDType ; Level : LogType) return boolean ; - impure function IsLoggingEnabled(Level : LogType) return boolean ; + + procedure ReportLogEnables ; + impure function GetAlertLogName(AlertLogID : AlertLogIDType) return string ; ------------------------------------------------------------ procedure SetAlertLogOptions ( @@ -174,6 +240,14 @@ package AlertLogPkg is impure function GetAlertPassName return string ; impure function GetAlertFailName 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 ; + end AlertLogPkg ; --- /////////////////////////////////////////////////////////////////////////// @@ -206,8 +280,8 @@ package body AlertLogPkg is ------------------------------------------------------------ procedure SetJustify ; - procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (0,0,0) ) ; 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 ; impure function GetAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertCountType ; impure function GetEnabledAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertCountType ; @@ -237,6 +311,7 @@ package body AlertLogPkg is procedure SetAlertLogName(Name : string ) ; procedure SetNumAlertLogIDs (NewNumAlertLogIDs : integer) ; impure function FindAlertLogID(Name : string ) return AlertLogIDType ; + impure function FindAlertLogID(Name : string ; ParentID : AlertLogIDType) return AlertLogIDType ; impure function GetAlertLogID(Name : string ; ParentID : AlertLogIDType) return AlertLogIDType ; procedure Initialize(NewNumAlertLogIDs : integer := MIN_NUM_AL_IDS) ; procedure Deallocate ; @@ -257,6 +332,9 @@ package body AlertLogPkg is impure function IsLoggingEnabled(AlertLogID : AlertLogIDType ; Level : LogType) return boolean ; + procedure ReportLogEnables ; + impure function GetAlertLogName(AlertLogID : AlertLogIDType) return string ; + ------------------------------------------------------------ -- Reporting Accessor procedure SetAlertLogOptions ( @@ -569,30 +647,32 @@ package body AlertLogPkg is ------------------------------------------------------------ AlertLogID : AlertLogIDType ; Prefix : string ; - IndentAmount : integer + IndentAmount : integer ; + ReportAll : boolean ) is variable buf : line ; begin for i in AlertLogID+1 to NumAlertLogIDs loop if AlertLogID = AlertLogPtr(i).ParentID then - -- Write(buf, Prefix & " " & AlertLogPtr(i).Name.all ) ; --- Write(buf, Prefix & " " & justify(AlertLogPtr(i).Name.all, LEFT, ReportJustifyAmountVar - IndentAmount)) ; - Write(buf, Prefix & " " & LeftJustify(AlertLogPtr(i).Name.all, ReportJustifyAmountVar - IndentAmount)) ; - write(buf, " Failures: " & to_string(AlertLogPtr(i).AlertCount(FAILURE) ) ) ; - write(buf, " Errors: " & to_string(AlertLogPtr(i).AlertCount(ERROR) ) ) ; - write(buf, " Warnings: " & to_string(AlertLogPtr(i).AlertCount(WARNING) ) ) ; - WriteLine(buf) ; + if ReportAll or SumAlertCount(AlertLogPtr(i).AlertCount) > 0 then + Write(buf, Prefix & " " & LeftJustify(AlertLogPtr(i).Name.all, ReportJustifyAmountVar - IndentAmount)) ; + write(buf, " Failures: " & to_string(AlertLogPtr(i).AlertCount(FAILURE) ) ) ; + write(buf, " Errors: " & to_string(AlertLogPtr(i).AlertCount(ERROR) ) ) ; + write(buf, " Warnings: " & to_string(AlertLogPtr(i).AlertCount(WARNING) ) ) ; + WriteLine(buf) ; + end if ; PrintChild( AlertLogID => i, Prefix => Prefix & " ", - IndentAmount => IndentAmount + 2 + IndentAmount => IndentAmount + 2, + ReportAll => ReportAll ) ; end if ; end loop ; end procedure PrintChild ; ------------------------------------------------------------ - procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (0,0,0) ) is + procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (0,0,0) ; ReportAll : boolean := TRUE) is ------------------------------------------------------------ variable NumErrors : integer ; variable NumDisabledErrors : integer ; @@ -627,7 +707,8 @@ package body AlertLogPkg is PrintChild( AlertLogID => AlertLogID, Prefix => ReportPrefix & " ", - IndentAmount => 2 + IndentAmount => 2, + ReportAll => ReportAll ) ; end if ; end procedure ReportAlerts ; @@ -649,11 +730,11 @@ package body AlertLogPkg is ------------------------------------------------------------ begin AlertLogPtr(ALERTLOG_BASE_ID).AlertCount := (0, 0, 0) ; - AlertLogPtr(ALERTLOG_BASE_ID).AlertStopCount := (integer'right, integer'right, 0) ; + AlertLogPtr(ALERTLOG_BASE_ID).AlertStopCount := (FAILURE => 0, ERROR => integer'right, WARNING => integer'right) ; - for i in ALERTLOG_BASE_ID to NumAlertLogIDs loop + for i in ALERTLOG_BASE_ID + 1 to NumAlertLogIDs loop AlertLogPtr(i).AlertCount := (0, 0, 0) ; - AlertLogPtr(ALERTLOG_BASE_ID).AlertStopCount := (integer'right, integer'right, integer'right) ; + AlertLogPtr(i).AlertStopCount := (FAILURE => integer'right, ERROR => integer'right, WARNING => integer'right) ; end loop ; end procedure ClearAlerts ; @@ -723,8 +804,13 @@ package body AlertLogPkg is LogEnabled := (FALSE, FALSE, FALSE) ; AlertStopCount := (FAILURE => 0, ERROR => integer'right, WARNING => integer'right) ; else - AlertEnabled := AlertLogPtr(ALERTLOG_BASE_ID).AlertEnabled ; - LogEnabled := AlertLogPtr(ALERTLOG_BASE_ID).LogEnabled ; + if ParentID < ALERTLOG_BASE_ID then + AlertEnabled := AlertLogPtr(ALERTLOG_BASE_ID).AlertEnabled ; + LogEnabled := AlertLogPtr(ALERTLOG_BASE_ID).LogEnabled ; + else + AlertEnabled := AlertLogPtr(ParentID).AlertEnabled ; + LogEnabled := AlertLogPtr(ParentID).LogEnabled ; + end if ; AlertStopCount := (FAILURE => integer'right, ERROR => integer'right, WARNING => integer'right) ; end if ; AlertLogPtr(AlertLogID) := new AlertLogRecType'( @@ -860,17 +946,35 @@ package body AlertLogPkg is end loop ; return ALERTLOG_ID_NOT_FOUND ; -- not found end function FindAlertLogID ; - + + ------------------------------------------------------------ + impure function FindAlertLogID(Name : string ; ParentID : AlertLogIDType) return AlertLogIDType is + ------------------------------------------------------------ + variable CurParentID : AlertLogIDType ; + begin + for i in ALERTLOG_BASE_ID to NumAlertLogIDs loop + CurParentID := AlertLogPtr(i).ParentID ; + if Name = AlertLogPtr(i).Name.all and + (CurParentID = ParentID or CurParentID = ALERTLOG_ID_NOT_ASSIGNED or ParentID = ALERTLOG_ID_NOT_ASSIGNED) + then + return i ; + end if ; + end loop ; + return ALERTLOG_ID_NOT_FOUND ; -- not found + end function FindAlertLogID ; ------------------------------------------------------------ impure function GetAlertLogID(Name : string ; ParentID : AlertLogIDType) return AlertLogIDType is ------------------------------------------------------------ variable ResultID : AlertLogIDType ; begin - ResultID := FindAlertLogID(Name) ; + ResultID := FindAlertLogID(Name, ParentID) ; if ResultID /= ALERTLOG_ID_NOT_FOUND then -- found it, set ParentID - AlertLogPtr(ResultID).ParentID := ParentID ; + if AlertLogPtr(ResultID).ParentID = ALERTLOG_ID_NOT_ASSIGNED then + AlertLogPtr(ResultID).ParentID := ParentID ; + -- else -- do not update as ParentIDs are either same or input ParentID = ALERTLOG_ID_NOT_ASSIGNED + end if ; else ResultID := GetNextAlertLogID ; NewAlertLogRec(ResultID, Name, ParentID) ; @@ -974,7 +1078,53 @@ package body AlertLogPkg is return AlertLogPtr(AlertLogID).LogEnabled(Level) ; end if ; end function IsLoggingEnabled ; + + ------------------------------------------------------------ + -- PT Local + procedure PrintLogLevels( + ------------------------------------------------------------ + AlertLogID : AlertLogIDType ; + Prefix : string ; + IndentAmount : integer + ) is + variable buf : line ; + begin + write(buf, Prefix & " " & LeftJustify(AlertLogPtr(AlertLogID).Name.all, ReportJustifyAmountVar - IndentAmount)) ; + for i in LogIndexType loop + if AlertLogPtr(AlertLogID).LogEnabled(i) then +-- write(buf, " " & to_string(AlertLogPtr(AlertLogID).LogEnabled(i)) ) ; + write(buf, " " & to_string(i)) ; + end if ; + end loop ; + WriteLine(buf) ; + for i in AlertLogID+1 to NumAlertLogIDs loop + if AlertLogID = AlertLogPtr(i).ParentID then + PrintLogLevels( + AlertLogID => i, + Prefix => Prefix & " ", + IndentAmount => IndentAmount + 2 + ) ; + end if ; + end loop ; + end procedure PrintLogLevels ; + ------------------------------------------------------------ + procedure ReportLogEnables is + ------------------------------------------------------------ + begin + if ReportJustifyAmountVar <= 0 then + SetJustify ; + end if ; + PrintLogLevels(ALERTLOG_BASE_ID, "", 0) ; + end procedure ReportLogEnables ; + + ------------------------------------------------------------ + impure function GetAlertLogName(AlertLogID : AlertLogIDType) return string is + ------------------------------------------------------------ + begin + return AlertLogPtr(AlertLogID).Name.all ; + end function GetAlertLogName ; + ------------------------------------------------------------ procedure SetAlertLogOptions ( ------------------------------------------------------------ @@ -1080,6 +1230,47 @@ package body AlertLogPkg is --- /////////////////////////////////////////////////////////////////////////// --- /////////////////////////////////////////////////////////////////////////// + ------------------------------------------------------------ + -- package local + procedure EmptyOrCommentLine ( + -- Better as Function, but not supported in VHDL functions + ------------------------------------------------------------ + variable L : InOut line ; + variable Empty : out boolean + ) is + variable Valid : boolean ; + variable Char : character ; + constant NBSP : CHARACTER := CHARACTER'val(160); -- space character + begin + Empty := TRUE ; + + -- if line empty (null or 0 length), Empty = TRUE + if L = null or L.all'length = 0 then + return ; + end if ; + + -- if line starts with '#', empty = TRUE + if L.all(1) = '#' then + return ; + end if ; + + -- if line starts with '--', empty = TRUE + if L.all'length >= 2 and L.all(1) = '-' and L.all(2) = '-' then + return ; + end if ; + + -- Otherwise, remove white space and check for end of line + -- Code borrowed from David Bishop, skip_whitespace + WhiteSpLoop : while L /= null and L.all'length > 0 loop + if (L.all(1) = ' ' or L.all(1) = NBSP or L.all(1) = HT) then + read (L, Char, Valid) ; + else + Empty := FALSE ; + exit WhiteSpLoop ; + end if ; + end loop WhiteSpLoop ; + end procedure EmptyOrCommentLine ; + ------------------------------------------------------------ procedure Alert( ------------------------------------------------------------ @@ -1099,7 +1290,7 @@ package body AlertLogPkg is end procedure alert ; ------------------------------------------------------------ - procedure AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) is + procedure AlertIf( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR ) is ------------------------------------------------------------ begin if condition then @@ -1107,6 +1298,14 @@ package body AlertLogPkg is end if ; end procedure AlertIf ; + ------------------------------------------------------------ + -- deprecated + procedure AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + AlertIf( AlertLogID, condition, Message, Level) ; + end procedure AlertIf ; + ------------------------------------------------------------ procedure AlertIf( condition : boolean ; Message : string ; Level : AlertType := ERROR ) is ------------------------------------------------------------ @@ -1118,7 +1317,7 @@ package body AlertLogPkg is ------------------------------------------------------------ -- useful with exit conditions in a loop: exit when alert( not ReadValid, failure, "Read Failed") ; - impure function AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean is + impure function AlertIf( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean is ------------------------------------------------------------ begin if condition then @@ -1127,6 +1326,14 @@ package body AlertLogPkg is return condition ; end function AlertIf ; + ------------------------------------------------------------ + -- deprecated + impure function AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean is + ------------------------------------------------------------ + begin + return AlertIf( AlertLogID, condition, Message, Level) ; + end function AlertIf ; + ------------------------------------------------------------ impure function AlertIf( condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean is ------------------------------------------------------------ @@ -1138,7 +1345,7 @@ package body AlertLogPkg is end function AlertIf ; ------------------------------------------------------------ - procedure AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) is + procedure AlertIfNot( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR ) is ------------------------------------------------------------ begin if not condition then @@ -1146,6 +1353,14 @@ package body AlertLogPkg is end if ; end procedure AlertIfNot ; + ------------------------------------------------------------ + -- deprecated + procedure AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + AlertIfNot( AlertLogID, condition, Message, Level) ; + end procedure AlertIfNot ; + ------------------------------------------------------------ procedure AlertIfNot( condition : boolean ; Message : string ; Level : AlertType := ERROR ) is ------------------------------------------------------------ @@ -1157,7 +1372,7 @@ package body AlertLogPkg is ------------------------------------------------------------ -- useful with exit conditions in a loop: exit when alert( not ReadValid, failure, "Read Failed") ; - impure function AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean is + impure function AlertIfNot( AlertLogID : AlertLogIDType ; condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean is ------------------------------------------------------------ begin if not condition then @@ -1166,6 +1381,14 @@ package body AlertLogPkg is return not condition ; end function AlertIfNot ; + ------------------------------------------------------------ + -- deprecated + impure function AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean is + ------------------------------------------------------------ + begin + return AlertIfNot( AlertLogID, condition, Message, Level) ; + end function AlertIfNot ; + ------------------------------------------------------------ impure function AlertIfNot( condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean is ------------------------------------------------------------ @@ -1175,7 +1398,366 @@ package body AlertLogPkg is end if ; return not condition ; end function AlertIfNot ; + + -- With AlertLogID + ------------------------------------------------------------ + procedure AlertIfEqual( AlertLogID : AlertLogIDType ; L, R : std_logic ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?= R then + AlertLogStruct.Alert(AlertLogID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( AlertLogID : AlertLogIDType ; L, R : std_logic_vector ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?= R then + AlertLogStruct.Alert(AlertLogID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( AlertLogID : AlertLogIDType ; L, R : unsigned ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?= R then + AlertLogStruct.Alert(AlertLogID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( AlertLogID : AlertLogIDType ; L, R : signed ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?= R then + AlertLogStruct.Alert(AlertLogID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( AlertLogID : AlertLogIDType ; L, R : integer ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L = R then + AlertLogStruct.Alert(AlertLogID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( AlertLogID : AlertLogIDType ; L, R : real ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L = R then + AlertLogStruct.Alert(AlertLogID, Message & " L = R, L = " & to_string(L, 4) & " R = " & to_string(R, 4), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( AlertLogID : AlertLogIDType ; L, R : character ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L = R then + AlertLogStruct.Alert(AlertLogID, Message & " L = R, L = " & L & " R = " & R, Level) ; + end if ; + end procedure AlertIfEqual ; + ------------------------------------------------------------ + procedure AlertIfEqual( AlertLogID : AlertLogIDType ; L, R : string ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L = R then + AlertLogStruct.Alert(AlertLogID, Message & " L = R, L = " & L & " R = " & R, Level) ; + end if ; + end procedure AlertIfEqual ; + + -- Without AlertLogID + ------------------------------------------------------------ + procedure AlertIfEqual( L, R : std_logic ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( L, R : std_logic_vector ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( L, R : unsigned ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( L, R : signed ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( L, R : integer ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L = R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L = R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( L, R : real ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L = R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L = R, L = " & to_string(L, 4) & " R = " & to_string(R, 4), Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( L, R : character ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L = R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L = R, L = " & L & " R = " & R, Level) ; + end if ; + end procedure AlertIfEqual ; + + ------------------------------------------------------------ + procedure AlertIfEqual( L, R : string ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L = R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L = R, L = " & L & " R = " & R, Level) ; + end if ; + end procedure AlertIfEqual ; + + -- With AlertLogID + ------------------------------------------------------------ + procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ; L, R : std_logic ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?/= R then + AlertLogStruct.Alert(AlertLogID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ; L, R : std_logic_vector ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?/= R then + AlertLogStruct.Alert(AlertLogID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ; L, R : unsigned ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?/= R then + AlertLogStruct.Alert(AlertLogID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ; L, R : signed ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?/= R then + AlertLogStruct.Alert(AlertLogID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ; L, R : integer ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L /= R then + AlertLogStruct.Alert(AlertLogID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ; L, R : real ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L /= R then + AlertLogStruct.Alert(AlertLogID, Message & " L /= R, L = " & to_string(L, 4) & " R = " & to_string(R, 4), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ; L, R : character ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L /= R then + AlertLogStruct.Alert(AlertLogID, Message & " L /= R, L = " & L & " R = " & R, Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( AlertLogID : AlertLogIDType ; L, R : string ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L /= R then + AlertLogStruct.Alert(AlertLogID, Message & " L /= R, L = " & L & " R = " & R, Level) ; + end if ; + end procedure AlertIfNotEqual ; + + -- Without AlertLogID + ------------------------------------------------------------ + procedure AlertIfNotEqual( L, R : std_logic ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?/= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( L, R : std_logic_vector ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?/= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( L, R : unsigned ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?/= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( L, R : signed ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L ?/= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( L, R : integer ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L /= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L /= R, L = " & to_string(L) & " R = " & to_string(R), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( L, R : real ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L /= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L /= R, L = " & to_string(L, 4) & " R = " & to_string(R, 4), Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( L, R : character ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L /= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L /= R, L = " & L & " R = " & R, Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfNotEqual( L, R : string ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if L /= R then + AlertLogStruct.Alert(ALERT_DEFAULT_ID, Message & " L /= R, L = " & L & " R = " & R, Level) ; + end if ; + end procedure AlertIfNotEqual ; + + ------------------------------------------------------------ + procedure AlertIfDiff (AlertLogID : AlertLogIDType ; Name1, Name2 : string; Message : string := "" ; Level : AlertType := ERROR ) is + -- Open files and call AlertIfDiff[text, ...] + ------------------------------------------------------------ + file FileID1, FileID2 : text ; + variable status1, status2 : file_open_status ; + begin + file_open(status1, FileID1, Name1, READ_MODE) ; + file_open(status2, FileID2, Name2, READ_MODE) ; + if status1 = OPEN_OK and status2 = OPEN_OK then + AlertIfDiff (AlertLogID, FileID1, FileID2, Message, Level) ; + else + if status1 /= OPEN_OK then + AlertLogStruct.Alert(AlertLogID , Message & " File, " & Name1 & ", did not open", Level) ; + end if ; + if status2 /= OPEN_OK then + AlertLogStruct.Alert(AlertLogID , Message & " File, " & Name2 & ", did not open", Level) ; + end if ; + end if; + end procedure AlertIfDiff ; + + ------------------------------------------------------------ + procedure AlertIfDiff (Name1, Name2 : string; Message : string := "" ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + AlertIfDiff (ALERT_DEFAULT_ID, Name1, Name2, Message, Level) ; + end procedure AlertIfDiff ; + + ------------------------------------------------------------ + procedure AlertIfDiff (AlertLogID : AlertLogIDType ; file File1, File2 : text; Message : string := "" ; Level : AlertType := ERROR ) is + -- Simple diff. + ------------------------------------------------------------ + variable Buf1, Buf2 : line ; + variable File1Done, File2Done : boolean ; + variable LineCount : integer := 0 ; + begin + ReadLoop : loop + File1Done := EndFile(File1) ; + File2Done := EndFile(File2) ; + exit ReadLoop when File1Done or File2Done ; + + ReadLine(File1, Buf1) ; + ReadLine(File2, Buf2) ; + LineCount := LineCount + 1 ; + + if Buf1.all /= Buf2.all then + AlertLogStruct.Alert(AlertLogID , Message & " File miscompare on line " & to_string(LineCount), Level) ; + exit ReadLoop ; + end if ; + end loop ReadLoop ; + if File1Done /= File2Done then + if not File1Done then + AlertLogStruct.Alert(AlertLogID , Message & " File1 longer than File2 " & to_string(LineCount), Level) ; + end if ; + if not File2Done then + AlertLogStruct.Alert(AlertLogID , Message & " File2 longer than File1 " & to_string(LineCount), Level) ; + end if ; + end if; + end procedure AlertIfDiff ; + + ------------------------------------------------------------ + procedure AlertIfDiff (file File1, File2 : text; Message : string := "" ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + AlertIfDiff (ALERT_DEFAULT_ID, File1, File2, Message, Level) ; + end procedure AlertIfDiff ; + ------------------------------------------------------------ procedure SetAlertLogJustify is ------------------------------------------------------------ @@ -1184,19 +1766,26 @@ package body AlertLogPkg is end procedure SetAlertLogJustify ; ------------------------------------------------------------ - procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (others => 0) ) is + procedure ReportAlerts ( Name : String ; AlertCount : AlertCountType ) is ------------------------------------------------------------ begin - AlertLogStruct.ReportAlerts(Name, AlertLogID, ExternalErrors) ; + AlertLogStruct.ReportAlerts(Name, AlertCount) ; end procedure ReportAlerts ; ------------------------------------------------------------ - procedure ReportAlerts ( Name : String ; AlertCount : AlertCountType ) is + procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (others => 0) ) is ------------------------------------------------------------ begin - AlertLogStruct.ReportAlerts(Name, AlertCount) ; + AlertLogStruct.ReportAlerts(Name, AlertLogID, ExternalErrors, TRUE) ; end procedure ReportAlerts ; + ------------------------------------------------------------ + procedure ReportNonZeroAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (others => 0) ) is + ------------------------------------------------------------ + begin + AlertLogStruct.ReportAlerts(Name, AlertLogID, ExternalErrors, FALSE) ; + end procedure ReportNonZeroAlerts ; + ------------------------------------------------------------ procedure ClearAlerts is ------------------------------------------------------------ @@ -1360,6 +1949,13 @@ package body AlertLogPkg is return AlertLogStruct.FindAlertLogID(Name) ; end function FindAlertLogID ; + ------------------------------------------------------------ + impure function FindAlertLogID(Name : string ; ParentID : AlertLogIDType) return AlertLogIDType is + ------------------------------------------------------------ + begin + return AlertLogStruct.FindAlertLogID(Name, ParentID) ; + end function FindAlertLogID ; + ------------------------------------------------------------ impure function GetAlertLogID(Name : string ; ParentID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertLogIDType is ------------------------------------------------------------ @@ -1423,8 +2019,22 @@ package body AlertLogPkg is ------------------------------------------------------------ begin AlertLogStruct.SetLogEnable(AlertLogID, Level, Enable, DescendHierarchy) ; - end procedure SetLogEnable ; + end procedure SetLogEnable ; + ------------------------------------------------------------ + procedure ReportLogEnables is + ------------------------------------------------------------ + begin + AlertLogStruct.ReportLogEnables ; + end ReportLogEnables ; + + ------------------------------------------------------------ + impure function GetAlertLogName(AlertLogID : AlertLogIDType) return string is + ------------------------------------------------------------ + begin + return AlertLogStruct.GetAlertLogName(AlertLogID) ; + end GetAlertLogName ; + ------------------------------------------------------------ procedure SetAlertLogOptions ( ------------------------------------------------------------ @@ -1491,5 +2101,92 @@ package body AlertLogPkg is begin return AlertLogStruct.GetAlertFailName ; end function GetAlertFailName ; + + ------------------------------------------------------------ + function IsLogEnableType (Name : String) return boolean is + ------------------------------------------------------------ + -- type LogType is (ALWAYS, DEBUG, FINAL, INFO) ; -- NEVER + begin + if Name = "DEBUG" then return TRUE ; + elsif Name = "FINAL" then return TRUE ; + elsif Name = "INFO" then return TRUE ; + end if ; + return FALSE ; + end function IsLogEnableType ; + + ------------------------------------------------------------ + procedure ReadLogEnables (file AlertLogInitFile : text) is + -- Preferred Read format + -- Line 1: instance1_name log_enable log_enable log_enable + -- Line 2: instance2_name log_enable log_enable log_enable + -- when reading multiple log_enables on a line, they must be separated by a space + -- + --- Also supports alternate format from Lyle/.... + -- Line 1: instance1_name + -- Line 2: log enable + -- Line 3: instance2_name + -- Line 4: log enable + -- + ------------------------------------------------------------ + type ReadStateType is (GET_ID, GET_ENABLE) ; + variable ReadState : ReadStateType := GET_ID ; + variable buf : line ; + variable Empty : boolean ; + variable Name : string(1 to 80) ; + variable NameLen : integer ; + variable AlertLogID : AlertLogIDType ; + variable NumEnableRead : integer ; + variable LogLevel : LogType ; + begin + ReadState := GET_ID ; + ReadLineLoop : while not EndFile(AlertLogInitFile) loop + ReadLine(AlertLogInitFile, buf) ; + EmptyOrCommentLine(buf, Empty) ; + + ReadNameLoop : while not Empty loop + case ReadState is + when GET_ID => + sread(buf, Name, NameLen) ; + exit ReadNameLoop when NameLen = 0 ; + AlertLogID := GetAlertLogID(Name(1 to NameLen), ALERTLOG_ID_NOT_ASSIGNED) ; + ReadState := GET_ENABLE ; + NumEnableRead := 0 ; + + when GET_ENABLE => + sread(buf, Name, NameLen) ; + exit ReadNameLoop when NameLen = 0 ; + NumEnableRead := NumEnableRead + 1 ; + exit ReadNameLoop when not IsLogEnableType(Name(1 to NameLen)) ; + LogLevel := LogType'value(Name(1 to NameLen)) ; + SetLogEnable(AlertLogID, LogLevel, TRUE) ; + end case ; + end loop ReadNameLoop ; + -- if have read an enable, find next AlertLog Name + if NumEnableRead > 0 then + ReadState := GET_ID ; + end if ; + end loop ReadLineLoop ; + end procedure ReadLogEnables ; + + ------------------------------------------------------------ + procedure ReadLogEnables (FileName : string) is + ------------------------------------------------------------ + file AlertLogInitFile : text open READ_MODE is FileName ; + begin + ReadLogEnables(AlertLogInitFile) ; + end procedure ReadLogEnables ; + + ------------------------------------------------------------ + function PathTail (A : string) return string is + ------------------------------------------------------------ + alias aA : string(1 to A'length) is A ; + begin + for i in aA'length - 1 downto 1 loop + if aA(i) = ':' then + return aA(i+1 to aA'length-1) ; + end if ; + end loop ; + return aA ; + end function PathTail ; end package body AlertLogPkg ; \ No newline at end of file diff --git a/vhdl/osvvm/AlertLogPkg_body_BVUL.vhd b/vhdl/osvvm/AlertLogPkg_body_BVUL.vhd new file mode 100644 index 000000000..38f2bcd53 --- /dev/null +++ b/vhdl/osvvm/AlertLogPkg_body_BVUL.vhd @@ -0,0 +1,491 @@ +-- +-- File Name: AlertLogPkg_body_BVUL.vhd +-- Design Unit Name: AlertLogPkg +-- Revision: STANDARD VERSION, revision 2015.01 +-- +-- Maintainer: Jim Lewis email: jim@synthworks.com +-- Contributor(s): +-- Jim Lewis jim@synthworks.com +-- +-- +-- 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 +-- +-- +-- Copyright (c) 2015 by SynthWorks Design Inc. All rights reserved. +-- +-- Verbatim copies of this source file may be used and +-- distributed without restriction. +-- +-- This source file is free software; you can redistribute it +-- and/or modify it under the terms of the ARTISTIC License +-- as published by The Perl Foundation; either version 2.0 of +-- the License, or (at your option) any later version. +-- +-- This source 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 Artistic License for details. +-- +-- You should have received a copy of the license with this source. +-- If not download it from, +-- http://www.perlfoundation.org/artistic_license_2_0 +-- + + + + +--- /////////////////////////////////////////////////////////////////////////// +--- /////////////////////////////////////////////////////////////////////////// +--- /////////////////////////////////////////////////////////////////////////// + +use work.NamePkg.all ; + +package body AlertLogPkg is + + -- 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 ") ; -- , NEVER => "NEVER " + + -- Local + constant NUM_PREDEFINED_AL_IDS : AlertLogIDType := 2 ; -- Not including base + + type AlertToSeverityType is array (AlertType) of severity_level ; + constant ALERT_TO_SEVERITY : AlertToSeverityType := (WARNING => WARNING, ERROR => ERROR, FAILURE => FAILURE) ; -- , NEVER => "NEVER " + + + ------------------------------------------------------------ + procedure Alert( + ------------------------------------------------------------ + AlertLogID : AlertLogIDType ; + Message : string ; + Level : AlertType := ERROR + ) is + begin + report Message & "AlertLogID = " & to_string(AlertLogID) severity ALERT_TO_SEVERITY(Level) ; + end procedure alert ; + + ------------------------------------------------------------ + procedure Alert( Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + Alert(ALERT_DEFAULT_ID , Message, Level) ; + end procedure alert ; + + ------------------------------------------------------------ + procedure AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if condition then + Alert(AlertLogID , Message, Level) ; + end if ; + end procedure AlertIf ; + + ------------------------------------------------------------ + procedure AlertIf( condition : boolean ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if condition then + Alert(ALERT_DEFAULT_ID , Message, Level) ; + end if ; + end procedure AlertIf ; + + ------------------------------------------------------------ + -- useful with exit conditions in a loop: exit when alert( not ReadValid, failure, "Read Failed") ; + impure function AlertIf( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean is + ------------------------------------------------------------ + begin + if condition then + Alert(AlertLogID , Message, Level) ; + end if ; + return condition ; + end function AlertIf ; + + ------------------------------------------------------------ + impure function AlertIf( condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean is + ------------------------------------------------------------ + begin + if condition then + Alert(ALERT_DEFAULT_ID, Message, Level) ; + end if ; + return condition ; + end function AlertIf ; + + ------------------------------------------------------------ + procedure AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if not condition then + Alert(AlertLogID, Message, Level) ; + end if ; + end procedure AlertIfNot ; + + ------------------------------------------------------------ + procedure AlertIfNot( condition : boolean ; Message : string ; Level : AlertType := ERROR ) is + ------------------------------------------------------------ + begin + if not condition then + Alert(ALERT_DEFAULT_ID, Message, Level) ; + end if ; + end procedure AlertIfNot ; + + ------------------------------------------------------------ + -- useful with exit conditions in a loop: exit when alert( not ReadValid, failure, "Read Failed") ; + impure function AlertIfNot( condition : boolean ; AlertLogID : AlertLogIDType ; Message : string ; Level : AlertType := ERROR ) return boolean is + ------------------------------------------------------------ + begin + if not condition then + Alert(AlertLogID, Message, Level) ; + end if ; + return not condition ; + end function AlertIfNot ; + + ------------------------------------------------------------ + impure function AlertIfNot( condition : boolean ; Message : string ; Level : AlertType := ERROR ) return boolean is + ------------------------------------------------------------ + begin + if not condition then + Alert(ALERT_DEFAULT_ID, Message, Level) ; + end if ; + return not condition ; + end function AlertIfNot ; + + ------------------------------------------------------------ + procedure SetAlertLogJustify is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetAlertLogJustify ; + + ------------------------------------------------------------ + procedure ReportAlerts ( Name : string := OSVVM_STRING_INIT_PARM_DETECT ; AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID ; ExternalErrors : AlertCountType := (others => 0) ) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure ReportAlerts ; + + ------------------------------------------------------------ + procedure ReportAlerts ( Name : String ; AlertCount : AlertCountType ) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure ReportAlerts ; + + ------------------------------------------------------------ + procedure ClearAlerts is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure ClearAlerts ; + + ------------------------------------------------------------ + function "+" (L, R : AlertCountType) return AlertCountType is + ------------------------------------------------------------ + variable Result : AlertCountType ; + begin + Result(FAILURE) := L(FAILURE) + R(FAILURE) ; + Result(ERROR) := L(ERROR) + R(ERROR) ; + Result(WARNING) := L(WARNING) + R(WARNING) ; + return Result ; + end function "+" ; + + ------------------------------------------------------------ + function "-" (L, R : AlertCountType) return AlertCountType is + ------------------------------------------------------------ + variable Result : AlertCountType ; + begin + Result(FAILURE) := L(FAILURE) - R(FAILURE) ; + Result(ERROR) := L(ERROR) - R(ERROR) ; + Result(WARNING) := L(WARNING) - R(WARNING) ; + return Result ; + end function "-" ; + + ------------------------------------------------------------ + function "-" (R : AlertCountType) return AlertCountType is + ------------------------------------------------------------ + variable Result : AlertCountType ; + begin + Result(FAILURE) := - R(FAILURE) ; + Result(ERROR) := - R(ERROR) ; + Result(WARNING) := - R(WARNING) ; + return Result ; + end function "-" ; + + ------------------------------------------------------------ + impure function SumAlertCount(AlertCount: AlertCountType) return integer is + ------------------------------------------------------------ + begin + return AlertCount(FAILURE) + AlertCount(ERROR) + AlertCount(WARNING) ; + end function SumAlertCount ; + + ------------------------------------------------------------ + impure function GetAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertCountType is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return (0, 0, 0) ; + end function GetAlertCount ; + + ------------------------------------------------------------ + impure function GetAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return integer is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return 0 ; + end function GetAlertCount ; + + ------------------------------------------------------------ + impure function GetEnabledAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertCountType is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return (0, 0, 0) ; + end function GetEnabledAlertCount ; + + ------------------------------------------------------------ + impure function GetEnabledAlertCount(AlertLogID : AlertLogIDType := ALERTLOG_BASE_ID) return integer is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return 0 ; + end function GetEnabledAlertCount ; + + ------------------------------------------------------------ + impure function GetDisabledAlertCount return AlertCountType is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return (0, 0, 0) ; + end function GetDisabledAlertCount ; + + ------------------------------------------------------------ + impure function GetDisabledAlertCount return integer is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return 0 ; + end function GetDisabledAlertCount ; + + ------------------------------------------------------------ + impure function GetDisabledAlertCount(AlertLogID: AlertLogIDType) return AlertCountType is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return (0, 0, 0) ; + end function GetDisabledAlertCount ; + + ------------------------------------------------------------ + impure function GetDisabledAlertCount(AlertLogID: AlertLogIDType) return integer is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return 0 ; + end function GetDisabledAlertCount ; + + ------------------------------------------------------------ + procedure log( + ------------------------------------------------------------ + AlertLogID : AlertLogIDType ; + Message : string ; + Level : LogType := ALWAYS + ) is + begin + report Message & "AlertLogID = " & to_string(AlertLogID) & " Level = " & to_string(Level) ; + end procedure log ; + + ------------------------------------------------------------ + procedure log( Message : string ; Level : LogType := ALWAYS) is + ------------------------------------------------------------ + begin + Log(LOG_DEFAULT_ID, Message, Level) ; + end procedure log ; + + ------------------------------------------------------------ + impure function IsLoggingEnabled(AlertLogID : AlertLogIDType ; Level : LogType) return boolean is + ------------------------------------------------------------ + begin +-- returns true when log level is enabled +alert("AlertLogPkg: procedure must be implemented", FAILURE) ; +-- return AlertLogStruct.IsLoggingEnabled(AlertLogID, Level) ; + return FALSE ; + end function IsLoggingEnabled ; + + ------------------------------------------------------------ + impure function IsLoggingEnabled(Level : LogType) return boolean is + ------------------------------------------------------------ + begin +-- returns true when log level is enabled +alert("AlertLogPkg: procedure must be implemented", FAILURE) ; +-- return AlertLogStruct.IsLoggingEnabled(LOG_DEFAULT_ID, Level) ; + return FALSE ; + end function IsLoggingEnabled ; + + ------------------------------------------------------------ + procedure SetAlertLogName(Name : string ) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetAlertLogName ; + + ------------------------------------------------------------ + procedure InitializeAlertLogStruct is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure InitializeAlertLogStruct ; + + ------------------------------------------------------------ + procedure DeallocateAlertLogStruct is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure DeallocateAlertLogStruct ; + + ------------------------------------------------------------ + impure function FindAlertLogID(Name : string ) return AlertLogIDType is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return 0 ; + end function FindAlertLogID ; + + ------------------------------------------------------------ + impure function GetAlertLogID(Name : string ; ParentID : AlertLogIDType := ALERTLOG_BASE_ID) return AlertLogIDType is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return 0 ; + end function GetAlertLogID ; + + ------------------------------------------------------------ + procedure SetGlobalAlertEnable (A : boolean := TRUE) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetGlobalAlertEnable ; + + ------------------------------------------------------------ + -- Set using constant. Set before code runs. + impure function SetGlobalAlertEnable (A : boolean := TRUE) return boolean is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return A ; + end function SetGlobalAlertEnable ; + + ------------------------------------------------------------ + procedure SetAlertStopCount(AlertLogID : AlertLogIDType ; Level : AlertType ; Count : integer) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetAlertStopCount ; + + ------------------------------------------------------------ + procedure SetAlertStopCount(Level : AlertType ; Count : integer) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetAlertStopCount ; + + ------------------------------------------------------------ + procedure SetAlertEnable(Level : AlertType ; Enable : boolean) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetAlertEnable ; + + ------------------------------------------------------------ + procedure SetAlertEnable(AlertLogID : AlertLogIDType ; Level : AlertType ; Enable : boolean ; DescendHierarchy : boolean := TRUE) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetAlertEnable ; + + ------------------------------------------------------------ + procedure SetLogEnable(Level : LogType ; Enable : boolean) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetLogEnable ; + + ------------------------------------------------------------ + procedure SetLogEnable(AlertLogID : AlertLogIDType ; Level : LogType ; Enable : boolean ; DescendHierarchy : boolean := TRUE) is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetLogEnable ; + + ------------------------------------------------------------ + procedure SetAlertLogOptions ( + ------------------------------------------------------------ + FailOnWarning : AlertLogOptionsType := OPT_INIT_PARM_DETECT ; + FailOnDisabledErrors : AlertLogOptionsType := OPT_INIT_PARM_DETECT ; + ReportHierarchy : AlertLogOptionsType := OPT_INIT_PARM_DETECT ; + WriteAlertLevel : AlertLogOptionsType := OPT_INIT_PARM_DETECT ; + WriteAlertName : AlertLogOptionsType := OPT_INIT_PARM_DETECT ; + WriteAlertTime : AlertLogOptionsType := OPT_INIT_PARM_DETECT ; + WriteLogLevel : AlertLogOptionsType := OPT_INIT_PARM_DETECT ; + WriteLogName : AlertLogOptionsType := OPT_INIT_PARM_DETECT ; + WriteLogTime : 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 + ) is + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + end procedure SetAlertLogOptions ; + + ------------------------------------------------------------ + impure function GetAlertReportPrefix return string is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return "" ; + end function GetAlertReportPrefix ; + + ------------------------------------------------------------ + impure function GetAlertDoneName return string is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return "" ; + end function GetAlertDoneName ; + + ------------------------------------------------------------ + impure function GetAlertPassName return string is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return "" ; + end function GetAlertPassName ; + + ------------------------------------------------------------ + impure function GetAlertFailName return string is + ------------------------------------------------------------ + begin + alert("AlertLogPkg: procedure not implemented for BVUL") ; + return "" ; + end function GetAlertFailName ; + +end package body AlertLogPkg ; \ No newline at end of file diff --git a/vhdl/osvvm/demo/AlertLog_Demo_Global.vhd b/vhdl/osvvm/demo/AlertLog_Demo_Global.vhd index b7afc09f1..4a59cc9af 100644 --- a/vhdl/osvvm/demo/AlertLog_Demo_Global.vhd +++ b/vhdl/osvvm/demo/AlertLog_Demo_Global.vhd @@ -58,8 +58,6 @@ library osvvm ; use osvvm.TranscriptPkg.all ; use osvvm.AlertLogPkg.all ; ---use work.TextUtilPkg.all ; - entity AlertLog_Demo_Global is end AlertLog_Demo_Global ; architecture hierarchy of AlertLog_Demo_Global is diff --git a/vhdl/osvvm/demo/AlertLog_Demo_Hierarchy.vhd b/vhdl/osvvm/demo/AlertLog_Demo_Hierarchy.vhd index 41286ed63..9d62cec17 100644 --- a/vhdl/osvvm/demo/AlertLog_Demo_Hierarchy.vhd +++ b/vhdl/osvvm/demo/AlertLog_Demo_Hierarchy.vhd @@ -61,8 +61,6 @@ library osvvm ; use osvvm.TranscriptPkg.all ; use osvvm.AlertLogPkg.all ; --- use work.TextUtilPkg.all ; - entity AlertLog_Demo_Hierarchy is end AlertLog_Demo_Hierarchy ; architecture hierarchy of AlertLog_Demo_Hierarchy is diff --git a/vhdl/osvvm/demo/Demo_Rand.vhd b/vhdl/osvvm/demo/Demo_Rand.vhd new file mode 100644 index 000000000..edf69018c --- /dev/null +++ b/vhdl/osvvm/demo/Demo_Rand.vhd @@ -0,0 +1,282 @@ +-- +-- File Name: Demo_Rand.vhd +-- Design Unit Name: Demo_Rand +-- Revision: STANDARD VERSION, revision 2015.03 +-- +-- Maintainer: Jim Lewis email: jim@synthworks.com +-- Contributor(s): +-- Jim Lewis email: jim@synthworks.com +-- +-- Description: +-- Demonstration program for RandomPkg.vhd +-- +-- Developed for: +-- SynthWorks Design Inc. +-- VHDL Training Classes +-- 11898 SW 128th Ave. Tigard, Or 97223 +-- http://www.SynthWorks.com +-- +-- Revision History: +-- Date Version Description +-- 02/2009: 1.0 Initial revision and First Public Released Version +-- 03/2009 1.1 Minor tweek to printing +-- 03/2015 2015.03 Updated FAVOR_BIG to FavorBig and FAVOR_SMALL to FavorSmall +-- +-- Copyright (c) 2009 by SynthWorks Design Inc. All rights reserved. +-- +-- Verbatim copies of this source file may be used and +-- distributed without restriction. +-- +-- This source file is free software; you can redistribute it +-- and/or modify it under the terms of the ARTISTIC License +-- as published by The Perl Foundation; either version 2.0 of +-- the License, or (at your option) any later version. +-- +-- This source 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 Artistic License for details. +-- +-- You should have received a copy of the license with this source. +-- If not download it from, +-- http://www.perlfoundation.org/artistic_license_2_0 +-- +library IEEE ; + use ieee.std_logic_1164.all ; + use std.textio.all ; + use ieee.std_logic_textio.all ; + +Package TestSupportPkg is + type integer_array is array (integer range <>) of integer ; + + procedure TestInit (TestName : string ; variable Results : inout integer_array ) ; + procedure TestInit (TestName : string ; variable Results : inout integer_array ; variable Count : inout natural ) ; + procedure AccumulateResults (IntVal : integer ; Num : integer ; variable Results : inout integer_array) ; + procedure PrintResults (Results : integer_array) ; + +end TestSupportPkg ; +Package body TestSupportPkg is + procedure TestInit (TestName : string ; variable Results : inout integer_array ) is + begin + write(OUTPUT, LF&LF & TestName & LF ) ; + Results := (Results'range => 0) ; + write(OUTPUT, "1st 20 values = ") ; + end ; + + procedure TestInit (TestName : string ; variable Results : inout integer_array ; variable Count : inout natural ) is + begin + Count := Count + 1 ; + write(OUTPUT, LF&LF & "Test " & integer'image(Count) & ": " & TestName & LF ) ; + Results := (Results'range => 0) ; + write(OUTPUT, "1st 20 values = ") ; + end ; + + procedure AccumulateResults (IntVal : integer ; Num : integer ; variable Results : inout integer_array) is + begin + Results(IntVal) :=Results(IntVal) + 1 ; + if Num < 20 then + write(OUTPUT, integer'image(IntVal) & " ") ; + end if ; + end ; + + procedure PrintResults (Results : integer_array) is + begin + write(OUTPUT, LF & "Accumulated Results. Expecting approximately 1000 of each per weight." & LF) ; + for i in Results'range loop + if Results(i) > 0 then + write(OUTPUT, "** ") ; + write(OUTPUT, integer'image(i) & " : " & integer'image(Results(i)) & LF) ; + end if ; + end loop ; + end ; +end TestSupportPkg ; + +library IEEE ; + use ieee.std_logic_1164.all ; + use ieee.numeric_std.all ; + + use std.textio.all ; + use ieee.std_logic_textio.all ; + +library SynthWorks ; + use SynthWorks.RandomBasePkg.all ; + use SynthWorks.RandomPkg.all ; + +use work.TestSupportPkg.all ; + +entity Demo_Rand is +end Demo_Rand ; +architecture test of Demo_Rand is +begin + + + RandomGenProc : process + variable RV : RandomPType ; + + variable DataInt : integer ; + variable DataSlv : std_logic_vector(3 downto 0) ; + variable DataUnsigned : unsigned(3 downto 0) ; + variable DataSigned : signed(4 downto 0) ; + + -- Statistics + variable TestNum : integer := 0 ; + variable Results : integer_array (-100 to 100) := (others => 0) ; + variable writebuf : line ; + + begin + + RV.InitSeed(RV'instance_name) ; -- Initialize Seed. Typically done one time + + +write(OUTPUT, LF&LF& "Random Range Tests") ; + TestInit("RandInt(0, 7) Range 0-7", Results, TestNum) ; -- 1 + for i in 1 to 8000 loop -- Loop 1000x per value + DataInt := RV.RandInt(0, 7); + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RandInt(1, 13, (3, 7, 11) Range 1-13, Exclude 3,7,11", Results, TestNum) ; -- 2 + for i in 1 to 10000 loop -- Loop 1000x per value + DataInt := RV.RandInt(1, 13, (3, 7, 11)); + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RandSlv(0, 4, 4) Range 0-4", Results, TestNum) ; -- 3 + for i in 1 to 5000 loop -- Loop 1000x per value + DataSlv := RV.RandSlv(0, 4, 4); + AccumulateResults(to_integer(unsigned(DataSlv)), i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RandUnsigned(4, 9, (0 => 7), 4) Range 4-9, Exclude 7", Results, TestNum) ; -- 4 + for i in 1 to 5000 loop -- Loop 1000x per value + DataUnsigned := RV.RandUnsigned(4, 9, (0 => 7), 4); -- only 1 exclude element + AccumulateResults(to_integer(DataUnsigned), i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RandSigned(-4, 3, 5)", Results, TestNum) ; -- 5 + for i in 1 to 8000 loop -- Loop 1000x per value + DataSigned := RV.RandSigned(-4, 3, 5); + AccumulateResults(to_integer(DataSigned), i, Results) ; + end loop ; + PrintResults (Results) ; + + +write(OUTPUT, LF&LF& "Random Set Tests") ; + TestNum := 0 ; + TestInit("RandInt( (-50, -22, -14, -7, -2, 0, 3, 7, 9, 27, 49, 89, 99)). Set: (-50, -22, -14, -7, -2, 0, 3, 7, 9, 27, 49, 89, 99)", Results, TestNum) ; -- 1 + for i in 1 to 13000 loop -- Loop 1000x per value + DataInt := RV.RandInt( (-50, -22, -14, -7, -2, 0, 3, 7, 9, 27, 49, 89, 99)); + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RandInt( (-5, -1, 3, 7, 11), (-1, 7) ) Set (-5, -1, 3, 7, 11), Exclude (-1, 7)", Results, TestNum) ; -- 2 + for i in 1 to 3000 loop -- Loop 1000x per value + DataInt := RV.RandInt( (-5, -1, 3, 7, 11), (-1, 7) ); + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RandSlv( (1, 2, 3, 7, 11), 4)", Results, TestNum) ; -- 3 + for i in 1 to 5000 loop -- Loop 1000x per value + DataSlv := RV.RandSlv( (1, 2, 3, 7, 11), 4); + AccumulateResults(to_integer(unsigned(DataSlv)), i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RandUnsigned( (1, 2, 3, 11), (1 => 3), 4)", Results, TestNum) ; -- 4 + for i in 1 to 3000 loop -- Loop 1000x per value + DataUnsigned := RV.RandUnsigned( (1, 2, 3, 11), (1 => 3), 4); -- 1 element middle + AccumulateResults(to_integer(DataUnsigned), i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RandSigned( (-5, -1, 3, 7, 11), 5)", Results, TestNum) ; -- 5 + for i in 1 to 5000 loop -- Loop 1000x per value + DataSigned := RV.RandSigned( (-5, -1, 3, 7, 11), 5); + AccumulateResults(to_integer(DataSigned), i, Results) ; + end loop ; + PrintResults (Results) ; + + +write(OUTPUT, LF&LF& "Weighted Distribution Tests") ; + TestNum := 0 ; + -- There is also DistSlv, DistUnsigned, DistSigned + TestInit("RV.DistInt( (7, 2, 1) ) ", Results, TestNum) ; + for i in 1 to 10000 loop -- Loop 1000x per distribute weight + DataInt := RV.DistInt( (7, 2, 1) ) ; + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RV.DistInt( (0, 2, 0, 4, 0, 6, 0, 8, 0, 10), (3,9) );", Results, TestNum) ; + for i in 1 to 16000 loop -- Loop 1000x per distribute weight + DataInt := RV.DistInt( (0, 2, 0, 4, 0, 6, 0, 8, 0, 10), (3,9) ) ; + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + +write(OUTPUT, LF&LF& "Weighted Distribution with Value") ; + TestNum := 0 ; + -- There is also DistValSlv, DistValUnsigned, DistValSigned + TestInit("RV.DistValInt( ((1, 7), (3, 2), (5, 1)) ) ", Results, TestNum) ; + for i in 1 to 10000 loop -- Loop 1000x per distribute weight + DataInt := RV.DistValInt( ((1, 7), (3, 2), (5, 1)) ) ; + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("RV.DistValInt( ((1, 7), (3, 2), (5, 1)), (1=>3) ) Exclude 3", Results, TestNum) ; + for i in 1 to 8000 loop -- Loop 1000x per distribute weight + DataInt := RV.DistValInt( ((1, 7), (3, 2), (5, 1)), (1=>3) ) ; + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + +write(OUTPUT, LF&LF& "Mode Direct Tests") ; + -- There are also real return values + TestNum := 0 ; + TestInit("Integer Uniform: Integer Range (0 to 9)", Results, TestNum) ; + for i in 1 to 10000 loop -- Loop 1000x per value + DataInt := RV.uniform(0,9); + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("Integer FavorSmall: Integer Range (0 to 9)", Results, TestNum) ; + for i in 1 to 10000 loop -- Loop 1000x per value + DataInt := RV.FavorSmall(0,9); + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("Integer FavorBig: Integer Range (0 to 9)", Results, TestNum) ; + for i in 1 to 10000 loop -- Loop 1000x per value + DataInt := RV.FavorBig(0,9); + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("Integer NORMAL, 50.0, 5.0 range -100 to 100", Results, TestNum) ; + for i in 1 to 100000 loop -- Loop 1000x per value + DataInt := RV.Normal(50.0, 5.0, -100, 100); + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + TestInit("Integer Poisson, 10.0, -100, 100", Results, TestNum) ; + for i in 1 to 10000 loop -- Loop 1000x per value + DataInt := RV.Poisson(10.0, -100, 100) ; + AccumulateResults(DataInt, i, Results) ; + end loop ; + PrintResults (Results) ; + + wait ; + end process RandomGenProc ; + +end test ; \ No newline at end of file diff --git a/vhdl/osvvm/doc/AlertLogPkg_interface_guide.pdf b/vhdl/osvvm/doc/AlertLogPkg_interface_guide.pdf new file mode 100644 index 000000000..7eaec9d03 Binary files /dev/null and b/vhdl/osvvm/doc/AlertLogPkg_interface_guide.pdf differ diff --git a/vhdl/osvvm/doc/AlertLogPkg_user_guide.pdf b/vhdl/osvvm/doc/AlertLogPkg_user_guide.pdf index 380cc2d44..9a7c59fa3 100644 Binary files a/vhdl/osvvm/doc/AlertLogPkg_user_guide.pdf and b/vhdl/osvvm/doc/AlertLogPkg_user_guide.pdf differ diff --git a/vhdl/osvvm/doc/osvvm_release_notes.pdf b/vhdl/osvvm/doc/osvvm_release_notes.pdf index 8611de3c8..c96ac129e 100644 Binary files a/vhdl/osvvm/doc/osvvm_release_notes.pdf and b/vhdl/osvvm/doc/osvvm_release_notes.pdf differ diff --git a/vunit/ui.py b/vunit/ui.py index 9453e2939..d29230d91 100644 --- a/vunit/ui.py +++ b/vunit/ui.py @@ -485,8 +485,9 @@ def add_osvvm(self, library_name="osvvm"): else: library = self.library(library_name) - library.add_source_files(join(self._builtin_vhdl_path, "osvvm", "*.vhd"), - preprocessors=[]) # No pre-processing at all + for f in glob(join(self._builtin_vhdl_path, "osvvm", "*.vhd")): + if basename(f) != 'AlertLogPkg_body_BVUL.vhd': + library.add_source_files(f, preprocessors=[]) class LibraryFacade: """