cpu_bsp.lst 420 KB

Edit Raw Blame History

L 1 "..\..\User\cpu_bsp.c"
N/*
N*********************************************************************************************************
N*                                                uC/CPU
N*                                    CPU CONFIGURATION & PORT LAYER
N*
N*                          (c) Copyright 2004-2015; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/CPU is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can find our product's user manual, API reference, release notes and
N*               more information at https://doc.micrium.com.
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                               CPU BOARD SUPPORT PACKAGE (BSP) FUNCTIONS
N*
N*                                              TEMPLATE
N*
N* Filename      : cpu_bsp.c
N* Version       : V1.30.02
N* Programmer(s) : ITJ
N*                 JBL
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                            INCLUDE FILES
N*********************************************************************************************************
N*/
N
N#define    CPU_BSP_MODULE
N#include  <cpu_core.h>
L 1 "..\..\uCOS-III\uC-CPU\cpu_core.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/CPU
N*                                    CPU CONFIGURATION & PORT LAYER
N*
N*                          (c) Copyright 2004-2011; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/CPU is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                           CORE CPU MODULE
N*
N* Filename      : cpu_core.h
N* Version       : V1.29.01
N* Programmer(s) : SR
N*                 ITJ
N*********************************************************************************************************
N* Note(s)       : (1) Assumes the following versions (or more recent) of software modules are included in
N*                     the project build :
N*
N*                     (a) uC/LIB V1.35.00
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*
N* Note(s) : (1) This core CPU header file is protected from multiple pre-processor inclusion through use of
N*               the  core CPU module present pre-processor macro definition.
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_CORE_MODULE_PRESENT                                /* See Note #1.                                         */
N#define  CPU_CORE_MODULE_PRESENT
N
N
N/*
N*********************************************************************************************************
N*                                               EXTERNS
N*********************************************************************************************************
N*/
N
N#ifdef   CPU_CORE_MODULE
S#define  CPU_CORE_EXT
N#else
N#define  CPU_CORE_EXT  extern
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                            INCLUDE FILES
N*
N* Note(s) : (1) CPU-configuration software files are located in the following directories :
N*
N*               (a) \<Your Product Application>\cpu_cfg.h
N*
N*               (b) (1) \<CPU-Compiler Directory>\cpu_*.*
N*                   (2) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*
N*
N*                       where
N*                               <Your Product Application>      directory path for Your Product's Application
N*                               <CPU-Compiler Directory>        directory path for common CPU-compiler software
N*                               <cpu>                           directory name for specific processor (CPU)
N*                               <compiler>                      directory name for specific compiler
N*
N*           (2) NO compiler-supplied standard library functions SHOULD be used.
N*
N*               (a) Standard library functions are implemented in the custom library module(s) :
N*
N*                       \<Custom Library Directory>\lib_*.*
N*
N*                           where
N*                                   <Custom Library Directory>      directory path for custom library software
N*
N*           (3) Compiler MUST be configured to include as additional include path directories :
N*
N*               (a) '\<Your Product Application>\' directory                            See Note #1a
N*
N*               (b) (1) '\<CPU-Compiler Directory>\'                  directory         See Note #1b1
N*                   (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory         See Note #1b2
N*
N*               (c) '\<Custom Library Directory>\' directory                            See Note #2a
N*********************************************************************************************************
N*/
N
N#include  <cpu.h>
L 1 "..\..\uCOS-III\uC-CPU\ARM-Cortex-M4\RealView\cpu.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/CPU
N*                                    CPU CONFIGURATION & PORT LAYER
N*
N*                          (c) Copyright 2004-2011; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/CPU is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                            CPU PORT FILE
N*
N*                                            ARM-Cortex-M4
N*                                      RealView Development Suite
N*                            RealView Microcontroller Development Kit (MDK)
N*                                       ARM Developer Suite (ADS)
N*                                            Keil uVision
N*
N* Filename      : cpu.h
N* Version       : V1.29.01.00
N* Programmer(s) : JJL
N*                 BAN
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*
N* Note(s) : (1) This CPU header file is protected from multiple pre-processor inclusion through use of
N*               the  CPU module present pre-processor macro definition.
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_MODULE_PRESENT                                     /* See Note #1.                                         */
N#define  CPU_MODULE_PRESENT
N
N
N/*
N*********************************************************************************************************
N*                                          CPU INCLUDE FILES
N*
N* Note(s) : (1) The following CPU files are located in the following directories :
N*
N*               (a) \<Your Product Application>\cpu_cfg.h
N*
N*               (b) (1) \<CPU-Compiler Directory>\cpu_def.h
N*                   (2) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*
N*
N*                       where
N*                               <Your Product Application>      directory path for Your Product's Application
N*                               <CPU-Compiler Directory>        directory path for common   CPU-compiler software
N*                               <cpu>                           directory name for specific CPU
N*                               <compiler>                      directory name for specific compiler
N*
N*           (2) Compiler MUST be configured to include as additional include path directories :
N*
N*               (a) '\<Your Product Application>\' directory                            See Note #1a
N*
N*               (b) (1) '\<CPU-Compiler Directory>\'                  directory         See Note #1b1
N*                   (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory         See Note #1b2
N*
N*           (3) Since NO custom library modules are included, 'cpu.h' may ONLY use configurations from
N*               CPU configuration file 'cpu_cfg.h' that do NOT reference any custom library definitions.
N*
N*               In other words, 'cpu.h' may use 'cpu_cfg.h' configurations that are #define'd to numeric
N*               constants or to NULL (i.e. NULL-valued #define's); but may NOT use configurations to
N*               custom library #define's (e.g. DEF_DISABLED or DEF_ENABLED).
N*********************************************************************************************************
N*/
N
N#include  <cpu_def.h>
L 1 "..\..\uCOS-III\uC-CPU\cpu_def.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/CPU
N*                                    CPU CONFIGURATION & PORT LAYER
N*
N*                          (c) Copyright 2004-2011; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/CPU is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                      CPU CONFIGURATION DEFINES
N*
N* Filename      : cpu_def.h
N* Version       : V1.29.01
N* Programmer(s) : ITJ
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*
N* Note(s) : (1) This CPU definition header file is protected from multiple pre-processor inclusion
N*               through use of the CPU definition module present pre-processor macro definition.
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_DEF_MODULE_PRESENT
N#define  CPU_DEF_MODULE_PRESENT
N
N
N/*
N*********************************************************************************************************
N*                                   CORE CPU MODULE VERSION NUMBER
N*
N* Note(s) : (1) (a) The core CPU module software version is denoted as follows :
N*
N*                       Vx.yy.zz
N*
N*                           where
N*                                   V               denotes 'Version' label
N*                                   x               denotes     major software version revision number
N*                                   yy              denotes     minor software version revision number
N*                                   zz              denotes sub-minor software version revision number
N*
N*               (b) The software version label #define is formatted as follows :
N*
N*                       ver = x.yyzz * 100 * 100
N*
N*                           where
N*                                   ver             denotes software version number scaled as an integer value
N*                                   x.yyzz          denotes software version number, where the unscaled integer
N*                                                       portion denotes the major version number & the unscaled
N*                                                       fractional portion denotes the (concatenated) minor
N*                                                       version numbers
N*********************************************************************************************************
N*/
N
N#define  CPU_CORE_VERSION                              12901u   /* See Note #1.                                         */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                       CPU WORD CONFIGURATION
N*
N* Note(s) : (1) Configure CPU_CFG_ADDR_SIZE & CPU_CFG_DATA_SIZE in 'cpu.h' with CPU's word sizes :
N*
N*                   CPU_WORD_SIZE_08             8-bit word size
N*                   CPU_WORD_SIZE_16            16-bit word size
N*                   CPU_WORD_SIZE_32            32-bit word size
N*                   CPU_WORD_SIZE_64            64-bit word size
N*
N*           (2) Configure CPU_CFG_ENDIAN_TYPE in 'cpu.h' with CPU's data-word-memory order :
N*
N*               (a) CPU_ENDIAN_TYPE_BIG         Big-   endian word order (CPU words' most  significant
N*                                                                         octet @ lowest memory address)
N*               (b) CPU_ENDIAN_TYPE_LITTLE      Little-endian word order (CPU words' least significant
N*                                                                         octet @ lowest memory address)
N*********************************************************************************************************
N*/
N
N                                                        /* ---------------------- CPU WORD SIZE ----------------------- */
N#define  CPU_WORD_SIZE_08                          1    /*  8-bit word size (in octets).                                */
N#define  CPU_WORD_SIZE_16                          2    /* 16-bit word size (in octets).                                */
N#define  CPU_WORD_SIZE_32                          4    /* 32-bit word size (in octets).                                */
N#define  CPU_WORD_SIZE_64                          8    /* 64-bit word size (in octets).                                */
N
N
N                                                        /* ------------------ CPU WORD-ENDIAN ORDER ------------------- */
N#define  CPU_ENDIAN_TYPE_NONE                      0u
N#define  CPU_ENDIAN_TYPE_BIG                       1u   /* Big-   endian word order (see Note #1a).                     */
N#define  CPU_ENDIAN_TYPE_LITTLE                    2u   /* Little-endian word order (see Note #1b).                     */
N
N
N/*
N*********************************************************************************************************
N*                                       CPU STACK CONFIGURATION
N*
N* Note(s) : (1) Configure CPU_CFG_STK_GROWTH in 'cpu.h' with CPU's stack growth order :
N*
N*               (a) CPU_STK_GROWTH_LO_TO_HI     CPU stack pointer increments to the next higher  stack
N*                                                   memory address after data is pushed onto the stack
N*               (b) CPU_STK_GROWTH_HI_TO_LO     CPU stack pointer decrements to the next lower   stack
N*                                                   memory address after data is pushed onto the stack
N*********************************************************************************************************
N*/
N
N                                                        /* ------------------ CPU STACK GROWTH ORDER ------------------ */
N#define  CPU_STK_GROWTH_NONE                       0u
N#define  CPU_STK_GROWTH_LO_TO_HI                   1u   /* CPU stk incs towards higher mem addrs (see Note #1a).        */
N#define  CPU_STK_GROWTH_HI_TO_LO                   2u   /* CPU stk decs towards lower  mem addrs (see Note #1b).        */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                   CRITICAL SECTION CONFIGURATION
N*
N* Note(s) : (1) Configure CPU_CFG_CRITICAL_METHOD with CPU's/compiler's critical section method :
N*
N*                                                       Enter/Exit critical sections by ...
N*
N*                   CPU_CRITICAL_METHOD_INT_DIS_EN      Disable/Enable interrupts
N*                   CPU_CRITICAL_METHOD_STATUS_STK      Push/Pop       interrupt status onto stack
N*                   CPU_CRITICAL_METHOD_STATUS_LOCAL    Save/Restore   interrupt status to local variable
N*
N*               (a) CPU_CRITICAL_METHOD_INT_DIS_EN  is NOT a preferred method since it does NOT support
N*                   multiple levels of interrupts.  However, with some CPUs/compilers, this is the only
N*                   available method.
N*
N*               (b) CPU_CRITICAL_METHOD_STATUS_STK    is one preferred method since it supports multiple
N*                   levels of interrupts.  However, this method assumes that the compiler provides C-level
N*                   &/or assembly-level functionality for the following :
N*
N*                     ENTER CRITICAL SECTION :
N*                       (1) Push/save   interrupt status onto a local stack
N*                       (2) Disable     interrupts
N*
N*                     EXIT  CRITICAL SECTION :
N*                       (3) Pop/restore interrupt status from a local stack
N*
N*               (c) CPU_CRITICAL_METHOD_STATUS_LOCAL  is one preferred method since it supports multiple
N*                   levels of interrupts.  However, this method assumes that the compiler provides C-level
N*                   &/or assembly-level functionality for the following :
N*
N*                     ENTER CRITICAL SECTION :
N*                       (1) Save    interrupt status into a local variable
N*                       (2) Disable interrupts
N*
N*                     EXIT  CRITICAL SECTION :
N*                       (3) Restore interrupt status from a local variable
N*
N*           (2) Critical section macro's most likely require inline assembly.  If the compiler does NOT
N*               allow inline assembly in C source files, critical section macro's MUST call an assembly
N*               subroutine defined in a 'cpu_a.asm' file located in the following software directory :
N*
N*                   \<CPU-Compiler Directory>\<cpu>\<compiler>\
N*
X
N*                       where
N*                               <CPU-Compiler Directory>    directory path for common   CPU-compiler software
N*                               <cpu>                       directory name for specific CPU
N*                               <compiler>                  directory name for specific compiler
N*
N*           (3) (a) To save/restore interrupt status, a local variable 'cpu_sr' of type 'CPU_SR' MAY need
N*                   to be declared (e.g. if 'CPU_CRITICAL_METHOD_STATUS_LOCAL' method is configured).
N*
N*                   (1) 'cpu_sr' local variable SHOULD be declared via the CPU_SR_ALLOC() macro which,
N*                        if used, MUST be declared following ALL other local variables (see any 'cpu.h
N*                        CRITICAL SECTION CONFIGURATION  Note #3a1').
N*
N*                        Example :
N*
N*                           void  Fnct (void)
N*                           {
N*                               CPU_INT08U  val_08;
N*                               CPU_INT16U  val_16;
N*                               CPU_INT32U  val_32;
N*                               CPU_SR_ALLOC();         MUST be declared after ALL other local variables
N*                                   :
N*                                   :
N*                           }
N*
N*               (b) Configure 'CPU_SR' data type with the appropriate-sized CPU data type large enough to
N*                   completely store the CPU's/compiler's status word.
N*********************************************************************************************************
N*/
N
N                                                        /* --------------- CPU CRITICAL SECTION METHODS --------------- */
N#define  CPU_CRITICAL_METHOD_NONE                  0u   /*                                                              */
N#define  CPU_CRITICAL_METHOD_INT_DIS_EN            1u   /* DIS/EN       ints                    (see Note #1a).         */
N#define  CPU_CRITICAL_METHOD_STATUS_STK            2u   /* Push/Pop     int status onto stk     (see Note #1b).         */
N#define  CPU_CRITICAL_METHOD_STATUS_LOCAL          3u   /* Save/Restore int status to local var (see Note #1c).         */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*
N* Note(s) : (1) See 'cpu_def.h  MODULE'.
N*********************************************************************************************************
N*/
N
N#endif                                                  /* End of CPU def module include.                               */
N
L 88 "..\..\uCOS-III\uC-CPU\ARM-Cortex-M4\RealView\cpu.h" 2
N#include  <cpu_cfg.h>                                           /* See Note #3.                                         */
L 1 "..\..\User\cpu_cfg.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/CPU
N*                                    CPU CONFIGURATION & PORT LAYER
N*
N*                          (c) Copyright 2004-2011; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/CPU is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                       CPU CONFIGURATION FILE
N*
N*                                              TEMPLATE
N*
N* Filename      : cpu_cfg.h
N* Version       : V1.29.01
N* Programmer(s) : SR
N*                 ITJ
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_CFG_MODULE_PRESENT
N#define  CPU_CFG_MODULE_PRESENT
N
N
N/*
N*********************************************************************************************************
N*                                       CPU NAME CONFIGURATION
N*
N* Note(s) : (1) Configure CPU_CFG_NAME_EN to enable/disable CPU host name feature :
N*
N*               (a) CPU host name storage
N*               (b) CPU host name API functions
N*
N*           (2) Configure CPU_CFG_NAME_SIZE with the desired ASCII string size of the CPU host name,
N*               including the terminating NULL character.
N*
N*               See also 'cpu_core.h  GLOBAL VARIABLES  Note #1'.
N*********************************************************************************************************
N*/
N
N                                                                /* Configure CPU host name feature (see Note #1) :      */
N#define  CPU_CFG_NAME_EN                         DEF_ENABLED
N                                                                /*   DEF_DISABLED  CPU host name DISABLED               */
N                                                                /*   DEF_ENABLED   CPU host name ENABLED                */
N
N                                                                /* Configure CPU host name ASCII string size ...        */
N#define  CPU_CFG_NAME_SIZE                                16    /* ... (see Note #2).                                   */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                     CPU TIMESTAMP CONFIGURATION
N*
N* Note(s) : (1) Configure CPU_CFG_TS_xx_EN to enable/disable CPU timestamp features :
N*
N*               (a) CPU_CFG_TS_32_EN   enable/disable 32-bit CPU timestamp feature
N*               (b) CPU_CFG_TS_64_EN   enable/disable 64-bit CPU timestamp feature
N*
N*           (2) (a) Configure CPU_CFG_TS_TMR_SIZE with the CPU timestamp timer's word size :
N*
N*                       CPU_WORD_SIZE_08         8-bit word size
N*                       CPU_WORD_SIZE_16        16-bit word size
N*                       CPU_WORD_SIZE_32        32-bit word size
N*                       CPU_WORD_SIZE_64        64-bit word size
N*
N*               (b) If the size of the CPU timestamp timer is not a binary multiple of 8-bit octets
N*                   (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple octet word
N*                   size SHOULD be configured (e.g. to 16-bits).  However, the minimum supported word
N*                   size for CPU timestamp timers is 8-bits.
N*
N*                   See also 'cpu_core.h  FUNCTION PROTOTYPES  CPU_TS_TmrRd()  Note #2a'.
N*********************************************************************************************************
N*/
N
N                                                                /* Configure CPU timestamp features (see Note #1) :     */
N#define  CPU_CFG_TS_32_EN                       DEF_ENABLED
N#define  CPU_CFG_TS_64_EN                       DEF_DISABLED
N                                                                /*   DEF_DISABLED  CPU timestamps DISABLED              */
N                                                                /*   DEF_ENABLED   CPU timestamps ENABLED               */
N
N                                                                /* Configure CPU timestamp timer word size ...          */
N                                                                /* ... (see Note #2) :                                  */
N#define  CPU_CFG_TS_TMR_SIZE                    CPU_WORD_SIZE_32
N
N
N/*
N*********************************************************************************************************
N*                        CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION
N*
N* Note(s) : (1) (a) Configure CPU_CFG_INT_DIS_MEAS_EN to enable/disable measuring CPU's interrupts
N*                   disabled time :
N*
N*                   (a)  Enabled,       if CPU_CFG_INT_DIS_MEAS_EN      #define'd in 'cpu_cfg.h'
N*
N*                   (b) Disabled,       if CPU_CFG_INT_DIS_MEAS_EN  NOT #define'd in 'cpu_cfg.h'
N*
N*                   See also 'cpu_core.h  FUNCTION PROTOTYPES  Note #1'.
N*
N*               (b) Configure CPU_CFG_INT_DIS_MEAS_OVRHD_NBR with the number of times to measure &
N*                   average the interrupts disabled time measurements overhead.
N*
N*                   Recommend a single (1) overhead time measurement, even for instruction-cache-enabled
N*                   CPUs, since critical sections are NOT typically called within instruction-cached loops.
N*                   Thus a single non-cached/non-averaged time measurement is a more realistic overhead
N*                   for the majority of non-cached interrupts disabled time measurements.
N*
N*                   See also 'cpu_core.c  CPU_IntDisMeasInit()  Note #3a'.
N*********************************************************************************************************
N*/
N
N#if 0                                                           /* Configure CPU interrupts disabled time ...           */
S#define  CPU_CFG_INT_DIS_MEAS_EN                                /* ... measurements feature (see Note #1a).             */
N#endif
N
N                                                                /* Configure number of interrupts disabled overhead ... */
N#define  CPU_CFG_INT_DIS_MEAS_OVRHD_NBR                    1u   /* ... time measurements (see Note #1b).                */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                    CPU COUNT ZEROS CONFIGURATION
N*
N* Note(s) : (1) (a) Configure CPU_CFG_LEAD_ZEROS_ASM_PRESENT  to define count leading  zeros bits
N*                   function(s) in :
N*
N*                   (1) 'cpu_a.asm',  if CPU_CFG_LEAD_ZEROS_ASM_PRESENT       #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable assembly-optimized function(s)
N*
N*                   (2) 'cpu_core.c', if CPU_CFG_LEAD_ZEROS_ASM_PRESENT   NOT #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable C-source-optimized function(s) otherwise
N*
N*               (b) Configure CPU_CFG_TRAIL_ZEROS_ASM_PRESENT to define count trailing zeros bits
N*                   function(s) in :
N*
N*                   (1) 'cpu_a.asm',  if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT      #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable assembly-optimized function(s)
N*
N*                   (2) 'cpu_core.c', if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT  NOT #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable C-source-optimized function(s) otherwise
N*********************************************************************************************************
N*/
N
N#if 1                                                           /* Configure CPU count leading  zeros bits ...          */
N#define  CPU_CFG_LEAD_ZEROS_ASM_PRESENT                         /* ... assembly-version (see Note #1a).                 */
N#endif
N
N#if 0                                                           /* Configure CPU count trailing zeros bits ...          */
S#define  CPU_CFG_TRAIL_ZEROS_ASM_PRESENT                        /* ... assembly-version (see Note #1b).                 */
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*********************************************************************************************************
N*/
N
N#endif                                                          /* End of CPU cfg module include.                       */
N
L 89 "..\..\uCOS-III\uC-CPU\ARM-Cortex-M4\RealView\cpu.h" 2
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                    CONFIGURE STANDARD DATA TYPES
N*
N* Note(s) : (1) Configure standard data types according to CPU-/compiler-specifications.
N*
N*           (2) (a) (1) 'CPU_FNCT_VOID' data type defined to replace the commonly-used function pointer
N*                       data type of a pointer to a function which returns void & has no arguments.
N*
N*                   (2) Example function pointer usage :
N*
N*                           CPU_FNCT_VOID  FnctName;
N*
N*                           FnctName();
N*
N*               (b) (1) 'CPU_FNCT_PTR'  data type defined to replace the commonly-used function pointer
N*                       data type of a pointer to a function which returns void & has a single void
N*                       pointer argument.
N*
N*                   (2) Example function pointer usage :
N*
N*                           CPU_FNCT_PTR   FnctName;
N*                           void          *p_obj
N*
N*                           FnctName(p_obj);
N*********************************************************************************************************
N*/
N
Ntypedef            void        CPU_VOID;
Ntypedef            char        CPU_CHAR;                        /*  8-bit character                                     */
Ntypedef  unsigned  char        CPU_BOOLEAN;                     /*  8-bit boolean or logical                            */
Ntypedef  unsigned  char        CPU_INT08U;                      /*  8-bit unsigned integer                              */
Ntypedef    signed  char        CPU_INT08S;                      /*  8-bit   signed integer                              */
Ntypedef  unsigned  short       CPU_INT16U;                      /* 16-bit unsigned integer                              */
Ntypedef    signed  short       CPU_INT16S;                      /* 16-bit   signed integer                              */
Ntypedef  unsigned  int         CPU_INT32U;                      /* 32-bit unsigned integer                              */
Ntypedef    signed  int         CPU_INT32S;                      /* 32-bit   signed integer                              */
Ntypedef  unsigned  long  long  CPU_INT64U;                      /* 64-bit unsigned integer                              */
Ntypedef    signed  long  long  CPU_INT64S;                      /* 64-bit   signed integer                              */
N
Ntypedef            float       CPU_FP32;                        /* 32-bit floating point                                */
Ntypedef            double      CPU_FP64;                        /* 64-bit floating point                                */
N
N
Ntypedef  volatile  CPU_INT08U  CPU_REG08;                       /*  8-bit register                                      */
Ntypedef  volatile  CPU_INT16U  CPU_REG16;                       /* 16-bit register                                      */
Ntypedef  volatile  CPU_INT32U  CPU_REG32;                       /* 32-bit register                                      */
Ntypedef  volatile  CPU_INT64U  CPU_REG64;                       /* 64-bit register                                      */
N
N
Ntypedef            void      (*CPU_FNCT_VOID)(void);            /* See Note #2a.                                        */
Ntypedef            void      (*CPU_FNCT_PTR )(void *p_obj);     /* See Note #2b.                                        */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                       CPU WORD CONFIGURATION
N*
N* Note(s) : (1) Configure CPU_CFG_ADDR_SIZE, CPU_CFG_DATA_SIZE, & CPU_CFG_DATA_SIZE_MAX with CPU's &/or
N*               compiler's word sizes :
N*
N*                   CPU_WORD_SIZE_08             8-bit word size
N*                   CPU_WORD_SIZE_16            16-bit word size
N*                   CPU_WORD_SIZE_32            32-bit word size
N*                   CPU_WORD_SIZE_64            64-bit word size
N*
N*           (2) Configure CPU_CFG_ENDIAN_TYPE with CPU's data-word-memory order :
N*
N*               (a) CPU_ENDIAN_TYPE_BIG         Big-   endian word order (CPU words' most  significant
N*                                                                         octet @ lowest memory address)
N*               (b) CPU_ENDIAN_TYPE_LITTLE      Little-endian word order (CPU words' least significant
N*                                                                         octet @ lowest memory address)
N*********************************************************************************************************
N*/
N
N                                                                /* Define  CPU         word sizes (see Note #1) :       */
N#define  CPU_CFG_ADDR_SIZE              CPU_WORD_SIZE_32        /* Defines CPU address word size  (in octets).          */
N#define  CPU_CFG_DATA_SIZE              CPU_WORD_SIZE_32        /* Defines CPU data    word size  (in octets).          */
N#define  CPU_CFG_DATA_SIZE_MAX          CPU_WORD_SIZE_64        /* Defines CPU maximum word size  (in octets).          */
N
N#define  CPU_CFG_ENDIAN_TYPE            CPU_ENDIAN_TYPE_LITTLE  /* Defines CPU data    word-memory order (see Note #2). */
N
N
N/*
N*********************************************************************************************************
N*                                 CONFIGURE CPU ADDRESS & DATA TYPES
N*********************************************************************************************************
N*/
N
N                                                                /* CPU address type based on address bus size.          */
N#if     (CPU_CFG_ADDR_SIZE == CPU_WORD_SIZE_32)
X#if     (4 == 4)
Ntypedef  CPU_INT32U  CPU_ADDR;
N#elif   (CPU_CFG_ADDR_SIZE == CPU_WORD_SIZE_16)
Stypedef  CPU_INT16U  CPU_ADDR;
S#else
Stypedef  CPU_INT08U  CPU_ADDR;
N#endif
N
N                                                                /* CPU data    type based on data    bus size.          */
N#if     (CPU_CFG_DATA_SIZE == CPU_WORD_SIZE_32)
X#if     (4 == 4)
Ntypedef  CPU_INT32U  CPU_DATA;
N#elif   (CPU_CFG_DATA_SIZE == CPU_WORD_SIZE_16)
Stypedef  CPU_INT16U  CPU_DATA;
S#else
Stypedef  CPU_INT08U  CPU_DATA;
N#endif
N
N
Ntypedef  CPU_DATA    CPU_ALIGN;                                 /* Defines CPU data-word-alignment size.                */
Ntypedef  CPU_ADDR    CPU_SIZE_T;                                /* Defines CPU standard 'size_t'   size.                */
N
N
N/*
N*********************************************************************************************************
N*                                       CPU STACK CONFIGURATION
N*
N* Note(s) : (1) Configure CPU_CFG_STK_GROWTH in 'cpu.h' with CPU's stack growth order :
N*
N*               (a) CPU_STK_GROWTH_LO_TO_HI     CPU stack pointer increments to the next higher  stack
N*                                                   memory address after data is pushed onto the stack
N*               (b) CPU_STK_GROWTH_HI_TO_LO     CPU stack pointer decrements to the next lower   stack
N*                                                   memory address after data is pushed onto the stack
N*********************************************************************************************************
N*/
N
N#define  CPU_CFG_STK_GROWTH     CPU_STK_GROWTH_HI_TO_LO         /* Defines CPU stack growth order (see Note #1).        */
N
Ntypedef  CPU_INT32U             CPU_STK;                        /* Defines CPU stack word size (in octets).             */
Ntypedef  CPU_ADDR               CPU_STK_SIZE;                   /* Defines CPU stack      size (in number of CPU_STKs). */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                   CRITICAL SECTION CONFIGURATION
N*
N* Note(s) : (1) Configure CPU_CFG_CRITICAL_METHOD with CPU's/compiler's critical section method :
N*
N*                                                       Enter/Exit critical sections by ...
N*
N*                   CPU_CRITICAL_METHOD_INT_DIS_EN      Disable/Enable interrupts
N*                   CPU_CRITICAL_METHOD_STATUS_STK      Push/Pop       interrupt status onto stack
N*                   CPU_CRITICAL_METHOD_STATUS_LOCAL    Save/Restore   interrupt status to local variable
N*
N*               (a) CPU_CRITICAL_METHOD_INT_DIS_EN  is NOT a preferred method since it does NOT support
N*                   multiple levels of interrupts.  However, with some CPUs/compilers, this is the only
N*                   available method.
N*
N*               (b) CPU_CRITICAL_METHOD_STATUS_STK    is one preferred method since it supports multiple
N*                   levels of interrupts.  However, this method assumes that the compiler provides C-level
N*                   &/or assembly-level functionality for the following :
N*
N*                     ENTER CRITICAL SECTION :
N*                       (1) Push/save   interrupt status onto a local stack
N*                       (2) Disable     interrupts
N*
N*                     EXIT  CRITICAL SECTION :
N*                       (3) Pop/restore interrupt status from a local stack
N*
N*               (c) CPU_CRITICAL_METHOD_STATUS_LOCAL  is one preferred method since it supports multiple
N*                   levels of interrupts.  However, this method assumes that the compiler provides C-level
N*                   &/or assembly-level functionality for the following :
N*
N*                     ENTER CRITICAL SECTION :
N*                       (1) Save    interrupt status into a local variable
N*                       (2) Disable interrupts
N*
N*                     EXIT  CRITICAL SECTION :
N*                       (3) Restore interrupt status from a local variable
N*
N*           (2) Critical section macro's most likely require inline assembly.  If the compiler does NOT
N*               allow inline assembly in C source files, critical section macro's MUST call an assembly
N*               subroutine defined in a 'cpu_a.asm' file located in the following software directory :
N*
N*                   \<CPU-Compiler Directory>\<cpu>\<compiler>\
N*
X
N*                       where
N*                               <CPU-Compiler Directory>    directory path for common   CPU-compiler software
N*                               <cpu>                       directory name for specific CPU
N*                               <compiler>                  directory name for specific compiler
N*
N*           (3) (a) To save/restore interrupt status, a local variable 'cpu_sr' of type 'CPU_SR' MAY need
N*                   to be declared (e.g. if 'CPU_CRITICAL_METHOD_STATUS_LOCAL' method is configured).
N*
N*                   (1) 'cpu_sr' local variable SHOULD be declared via the CPU_SR_ALLOC() macro which, if
N*                        used, MUST be declared following ALL other local variables.
N*
N*                        Example :
N*
N*                           void  Fnct (void)
N*                           {
N*                               CPU_INT08U  val_08;
N*                               CPU_INT16U  val_16;
N*                               CPU_INT32U  val_32;
N*                               CPU_SR_ALLOC();         MUST be declared after ALL other local variables
N*                                   :
N*                                   :
N*                           }
N*
N*               (b) Configure 'CPU_SR' data type with the appropriate-sized CPU data type large enough to
N*                   completely store the CPU's/compiler's status word.
N*********************************************************************************************************
N*/
N/*$PAGE*/
N                                                                /* Configure CPU critical method      (see Note #1) :   */
N#define  CPU_CFG_CRITICAL_METHOD    CPU_CRITICAL_METHOD_STATUS_LOCAL
N
Ntypedef  CPU_INT32U                 CPU_SR;                     /* Defines   CPU status register size (see Note #3b).   */
N
N                                                                /* Allocates CPU status register word (see Note #3a).   */
N#if     (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
X#if     (3u == 3u)
N#define  CPU_SR_ALLOC()             CPU_SR  cpu_sr = (CPU_SR)0
N#else
S#define  CPU_SR_ALLOC()
N#endif
N
N
N
N#define  CPU_INT_DIS()         do { cpu_sr = CPU_SR_Save(); } while (0) /* Save    CPU status word & disable interrupts.*/
N#define  CPU_INT_EN()          do { CPU_SR_Restore(cpu_sr); } while (0) /* Restore CPU status word.                     */
N
N
N#ifdef   CPU_CFG_INT_DIS_MEAS_EN
S                                                                        /* Disable interrupts, ...                      */
S                                                                        /* & start interrupts disabled time measurement.*/
S#define  CPU_CRITICAL_ENTER()  do { CPU_INT_DIS();         \
S                                    CPU_IntDisMeasStart(); }  while (0)
X#define  CPU_CRITICAL_ENTER()  do { CPU_INT_DIS();                                             CPU_IntDisMeasStart(); }  while (0)
S                                                                        /* Stop & measure   interrupts disabled time,   */
S                                                                        /* ...  & re-enable interrupts.                 */
S#define  CPU_CRITICAL_EXIT()   do { CPU_IntDisMeasStop();  \
S                                    CPU_INT_EN();          }  while (0)
X#define  CPU_CRITICAL_EXIT()   do { CPU_IntDisMeasStop();                                      CPU_INT_EN();          }  while (0)
S
N#else
N
N#define  CPU_CRITICAL_ENTER()  do { CPU_INT_DIS(); } while (0)          /* Disable   interrupts.                        */
N#define  CPU_CRITICAL_EXIT()   do { CPU_INT_EN();  } while (0)          /* Re-enable interrupts.                        */
N
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                    CPU COUNT ZEROS CONFIGURATION
N*
N* Note(s) : (1) (a) Configure CPU_CFG_LEAD_ZEROS_ASM_PRESENT  to define count leading  zeros bits
N*                   function(s) in :
N*
N*                   (1) 'cpu_a.asm',  if CPU_CFG_LEAD_ZEROS_ASM_PRESENT       #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable assembly-optimized function(s)
N*
N*                   (2) 'cpu_core.c', if CPU_CFG_LEAD_ZEROS_ASM_PRESENT   NOT #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable C-source-optimized function(s) otherwise
N*
N*               (b) Configure CPU_CFG_TRAIL_ZEROS_ASM_PRESENT to define count trailing zeros bits
N*                   function(s) in :
N*
N*                   (1) 'cpu_a.asm',  if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT      #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable assembly-optimized function(s)
N*
N*                   (2) 'cpu_core.c', if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT  NOT #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable C-source-optimized function(s) otherwise
N*********************************************************************************************************
N*/
N
N                                                                /* Configure CPU count leading  zeros bits ...          */
N#define  CPU_CFG_LEAD_ZEROS_ASM_PRESENT                         /* ... assembly-version (see Note #1a).                 */
N
N                                                                /* Configure CPU count trailing zeros bits ...          */
N#define  CPU_CFG_TRAIL_ZEROS_ASM_PRESENT                        /* ... assembly-version (see Note #1b).                 */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         FUNCTION PROTOTYPES
N*********************************************************************************************************
N*/
N
Nvoid        CPU_IntDis       (void);
Nvoid        CPU_IntEn        (void);
N
Nvoid        CPU_IntSrcDis    (CPU_INT08U  pos);
Nvoid        CPU_IntSrcEn     (CPU_INT08U  pos);
Nvoid        CPU_IntSrcPendClr(CPU_INT08U  pos);
NCPU_INT16S  CPU_IntSrcPrioGet(CPU_INT08U  pos);
Nvoid        CPU_IntSrcPrioSet(CPU_INT08U  pos,
N                              CPU_INT08U  prio);
N
N
NCPU_SR      CPU_SR_Save      (void);
Nvoid        CPU_SR_Restore   (CPU_SR      cpu_sr);
N
N
Nvoid        CPU_WaitForInt   (void);
Nvoid        CPU_WaitForExcept(void);
N
N
NCPU_DATA    CPU_RevBits      (CPU_DATA    val);
N
Nvoid        CPU_BitBandClr   (CPU_ADDR    addr,
N                              CPU_INT08U  bit_nbr);
Nvoid        CPU_BitBandSet   (CPU_ADDR    addr,
N                              CPU_INT08U  bit_nbr);
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          INTERRUPT SOURCES
N*********************************************************************************************************
N*/
N
N#define  CPU_INT_STK_PTR                                   0u
N#define  CPU_INT_RESET                                     1u
N#define  CPU_INT_NMI                                       2u
N#define  CPU_INT_HFAULT                                    3u
N#define  CPU_INT_MEM                                       4u
N#define  CPU_INT_BUSFAULT                                  5u
N#define  CPU_INT_USAGEFAULT                                6u
N#define  CPU_INT_RSVD_07                                   7u
N#define  CPU_INT_RSVD_08                                   8u
N#define  CPU_INT_RSVD_09                                   9u
N#define  CPU_INT_RSVD_10                                  10u
N#define  CPU_INT_SVCALL                                   11u
N#define  CPU_INT_DBGMON                                   12u
N#define  CPU_INT_RSVD_13                                  13u
N#define  CPU_INT_PENDSV                                   14u
N#define  CPU_INT_SYSTICK                                  15u
N#define  CPU_INT_EXT0                                     16u
N
N/*
N*********************************************************************************************************
N*                                            CPU REGISTERS
N*********************************************************************************************************
N*/
N
N#define  CPU_REG_NVIC_NVIC           (*((CPU_REG32 *)(0xE000E004)))             /* Int Ctrl'er Type Reg.                */
N#define  CPU_REG_NVIC_ST_CTRL        (*((CPU_REG32 *)(0xE000E010)))             /* SysTick Ctrl & Status Reg.           */
N#define  CPU_REG_NVIC_ST_RELOAD      (*((CPU_REG32 *)(0xE000E014)))             /* SysTick Reload      Value Reg.       */
N#define  CPU_REG_NVIC_ST_CURRENT     (*((CPU_REG32 *)(0xE000E018)))             /* SysTick Current     Value Reg.       */
N#define  CPU_REG_NVIC_ST_CAL         (*((CPU_REG32 *)(0xE000E01C)))             /* SysTick Calibration Value Reg.       */
N
N#define  CPU_REG_NVIC_SETEN(n)       (*((CPU_REG32 *)(0xE000E100 + (n) * 4u)))  /* IRQ Set En Reg.                      */
N#define  CPU_REG_NVIC_CLREN(n)       (*((CPU_REG32 *)(0xE000E180 + (n) * 4u)))  /* IRQ Clr En Reg.                      */
N#define  CPU_REG_NVIC_SETPEND(n)     (*((CPU_REG32 *)(0xE000E200 + (n) * 4u)))  /* IRQ Set Pending Reg.                 */
N#define  CPU_REG_NVIC_CLRPEND(n)     (*((CPU_REG32 *)(0xE000E280 + (n) * 4u)))  /* IRQ Clr Pending Reg.                 */
N#define  CPU_REG_NVIC_ACTIVE(n)      (*((CPU_REG32 *)(0xE000E300 + (n) * 4u)))  /* IRQ Active Reg.                      */
N#define  CPU_REG_NVIC_PRIO(n)        (*((CPU_REG32 *)(0xE000E400 + (n) * 4u)))  /* IRQ Prio Reg.                        */
N
N#define  CPU_REG_NVIC_CPUID          (*((CPU_REG32 *)(0xE000ED00)))             /* CPUID Base Reg.                      */
N#define  CPU_REG_NVIC_ICSR           (*((CPU_REG32 *)(0xE000ED04)))             /* Int Ctrl State  Reg.                 */
N#define  CPU_REG_NVIC_VTOR           (*((CPU_REG32 *)(0xE000ED08)))             /* Vect Tbl Offset Reg.                 */
N#define  CPU_REG_NVIC_AIRCR          (*((CPU_REG32 *)(0xE000ED0C)))             /* App Int/Reset Ctrl Reg.              */
N#define  CPU_REG_NVIC_SCR            (*((CPU_REG32 *)(0xE000ED10)))             /* System Ctrl Reg.                     */
N#define  CPU_REG_NVIC_CCR            (*((CPU_REG32 *)(0xE000ED14)))             /* Cfg    Ctrl Reg.                     */
N#define  CPU_REG_NVIC_SHPRI1         (*((CPU_REG32 *)(0xE000ED18)))             /* System Handlers  4 to  7 Prio.       */
N#define  CPU_REG_NVIC_SHPRI2         (*((CPU_REG32 *)(0xE000ED1C)))             /* System Handlers  8 to 11 Prio.       */
N#define  CPU_REG_NVIC_SHPRI3         (*((CPU_REG32 *)(0xE000ED20)))             /* System Handlers 12 to 15 Prio.       */
N#define  CPU_REG_NVIC_SHCSR          (*((CPU_REG32 *)(0xE000ED24)))             /* System Handler Ctrl & State Reg.     */
N#define  CPU_REG_NVIC_CFSR           (*((CPU_REG32 *)(0xE000ED28)))             /* Configurable Fault Status Reg.       */
N#define  CPU_REG_NVIC_HFSR           (*((CPU_REG32 *)(0xE000ED2C)))             /* Hard  Fault Status Reg.              */
N#define  CPU_REG_NVIC_DFSR           (*((CPU_REG32 *)(0xE000ED30)))             /* Debug Fault Status Reg.              */
N#define  CPU_REG_NVIC_MMFAR          (*((CPU_REG32 *)(0xE000ED34)))             /* Mem Manage Addr Reg.                 */
N#define  CPU_REG_NVIC_BFAR           (*((CPU_REG32 *)(0xE000ED38)))             /* Bus Fault  Addr Reg.                 */
N#define  CPU_REG_NVIC_AFSR           (*((CPU_REG32 *)(0xE000ED3C)))             /* Aux Fault Status Reg.                */
N
N#define  CPU_REG_NVIC_PFR0           (*((CPU_REG32 *)(0xE000ED40)))             /* Processor Feature Reg 0.             */
N#define  CPU_REG_NVIC_PFR1           (*((CPU_REG32 *)(0xE000ED44)))             /* Processor Feature Reg 1.             */
N#define  CPU_REG_NVIC_DFR0           (*((CPU_REG32 *)(0xE000ED48)))             /* Debug     Feature Reg 0.             */
N#define  CPU_REG_NVIC_AFR0           (*((CPU_REG32 *)(0xE000ED4C)))             /* Aux       Feature Reg 0.             */
N#define  CPU_REG_NVIC_MMFR0          (*((CPU_REG32 *)(0xE000ED50)))             /* Memory Model Feature Reg 0.          */
N#define  CPU_REG_NVIC_MMFR1          (*((CPU_REG32 *)(0xE000ED54)))             /* Memory Model Feature Reg 1.          */
N#define  CPU_REG_NVIC_MMFR2          (*((CPU_REG32 *)(0xE000ED58)))             /* Memory Model Feature Reg 2.          */
N#define  CPU_REG_NVIC_MMFR3          (*((CPU_REG32 *)(0xE000ED5C)))             /* Memory Model Feature Reg 3.          */
N#define  CPU_REG_NVIC_ISAFR0         (*((CPU_REG32 *)(0xE000ED60)))             /* ISA Feature Reg 0.                   */
N#define  CPU_REG_NVIC_ISAFR1         (*((CPU_REG32 *)(0xE000ED64)))             /* ISA Feature Reg 1.                   */
N#define  CPU_REG_NVIC_ISAFR2         (*((CPU_REG32 *)(0xE000ED68)))             /* ISA Feature Reg 2.                   */
N#define  CPU_REG_NVIC_ISAFR3         (*((CPU_REG32 *)(0xE000ED6C)))             /* ISA Feature Reg 3.                   */
N#define  CPU_REG_NVIC_ISAFR4         (*((CPU_REG32 *)(0xE000ED70)))             /* ISA Feature Reg 4.                   */
N#define  CPU_REG_NVIC_SW_TRIG        (*((CPU_REG32 *)(0xE000EF00)))             /* Software Trigger Int Reg.            */
N
N#define  CPU_REG_MPU_TYPE            (*((CPU_REG32 *)(0xE000ED90)))             /* MPU Type Reg.                        */
N#define  CPU_REG_MPU_CTRL            (*((CPU_REG32 *)(0xE000ED94)))             /* MPU Ctrl Reg.                        */
N#define  CPU_REG_MPU_REG_NBR         (*((CPU_REG32 *)(0xE000ED98)))             /* MPU Region Nbr Reg.                  */
N#define  CPU_REG_MPU_REG_BASE        (*((CPU_REG32 *)(0xE000ED9C)))             /* MPU Region Base Addr Reg.            */
N#define  CPU_REG_MPU_REG_ATTR        (*((CPU_REG32 *)(0xE000EDA0)))             /* MPU Region Attrib & Size Reg.        */
N
N#define  CPU_REG_DBG_CTRL            (*((CPU_REG32 *)(0xE000EDF0)))             /* Debug Halting Ctrl & Status Reg.     */
N#define  CPU_REG_DBG_SELECT          (*((CPU_REG32 *)(0xE000EDF4)))             /* Debug Core Reg Selector Reg.         */
N#define  CPU_REG_DBG_DATA            (*((CPU_REG32 *)(0xE000EDF8)))             /* Debug Core Reg Data     Reg.         */
N#define  CPU_REG_DBG_INT             (*((CPU_REG32 *)(0xE000EDFC)))             /* Debug Except & Monitor Ctrl Reg.     */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          CPU REGISTER BITS
N*********************************************************************************************************
N*/
N
N                                                                /* ---------- SYSTICK CTRL & STATUS REG BITS ---------- */
N#define  CPU_REG_NVIC_ST_CTRL_COUNTFLAG           0x00010000
N#define  CPU_REG_NVIC_ST_CTRL_CLKSOURCE           0x00000004
N#define  CPU_REG_NVIC_ST_CTRL_TICKINT             0x00000002
N#define  CPU_REG_NVIC_ST_CTRL_ENABLE              0x00000001
N
N
N                                                                /* -------- SYSTICK CALIBRATION VALUE REG BITS -------- */
N#define  CPU_REG_NVIC_ST_CAL_NOREF                0x80000000
N#define  CPU_REG_NVIC_ST_CAL_SKEW                 0x40000000
N
N                                                                /* -------------- INT CTRL STATE REG BITS ------------- */
N#define  CPU_REG_NVIC_ICSR_NMIPENDSET             0x80000000
N#define  CPU_REG_NVIC_ICSR_PENDSVSET              0x10000000
N#define  CPU_REG_NVIC_ICSR_PENDSVCLR              0x08000000
N#define  CPU_REG_NVIC_ICSR_PENDSTSET              0x04000000
N#define  CPU_REG_NVIC_ICSR_PENDSTCLR              0x02000000
N#define  CPU_REG_NVIC_ICSR_ISRPREEMPT             0x00800000
N#define  CPU_REG_NVIC_ICSR_ISRPENDING             0x00400000
N#define  CPU_REG_NVIC_ICSR_RETTOBASE              0x00000800
N
N                                                                /* ------------- VECT TBL OFFSET REG BITS ------------- */
N#define  CPU_REG_NVIC_VTOR_TBLBASE                0x20000000
N
N                                                                /* ------------ APP INT/RESET CTRL REG BITS ----------- */
N#define  CPU_REG_NVIC_AIRCR_ENDIANNESS            0x00008000
N#define  CPU_REG_NVIC_AIRCR_SYSRESETREQ           0x00000004
N#define  CPU_REG_NVIC_AIRCR_VECTCLRACTIVE         0x00000002
N#define  CPU_REG_NVIC_AIRCR_VECTRESET             0x00000001
N
N                                                                /* --------------- SYSTEM CTRL REG BITS --------------- */
N#define  CPU_REG_NVIC_SCR_SEVONPEND               0x00000010
N#define  CPU_REG_NVIC_SCR_SLEEPDEEP               0x00000004
N#define  CPU_REG_NVIC_SCR_SLEEPONEXIT             0x00000002
N
N                                                                /* ----------------- CFG CTRL REG BITS ---------------- */
N#define  CPU_REG_NVIC_CCR_STKALIGN                0x00000200
N#define  CPU_REG_NVIC_CCR_BFHFNMIGN               0x00000100
N#define  CPU_REG_NVIC_CCR_DIV_0_TRP               0x00000010
N#define  CPU_REG_NVIC_CCR_UNALIGN_TRP             0x00000008
N#define  CPU_REG_NVIC_CCR_USERSETMPEND            0x00000002
N#define  CPU_REG_NVIC_CCR_NONBASETHRDENA          0x00000001
N
N                                                                /* ------- SYSTEM HANDLER CTRL & STATE REG BITS ------- */
N#define  CPU_REG_NVIC_SHCSR_USGFAULTENA           0x00040000
N#define  CPU_REG_NVIC_SHCSR_BUSFAULTENA           0x00020000
N#define  CPU_REG_NVIC_SHCSR_MEMFAULTENA           0x00010000
N#define  CPU_REG_NVIC_SHCSR_SVCALLPENDED          0x00008000
N#define  CPU_REG_NVIC_SHCSR_BUSFAULTPENDED        0x00004000
N#define  CPU_REG_NVIC_SHCSR_MEMFAULTPENDED        0x00002000
N#define  CPU_REG_NVIC_SHCSR_USGFAULTPENDED        0x00001000
N#define  CPU_REG_NVIC_SHCSR_SYSTICKACT            0x00000800
N#define  CPU_REG_NVIC_SHCSR_PENDSVACT             0x00000400
N#define  CPU_REG_NVIC_SHCSR_MONITORACT            0x00000100
N#define  CPU_REG_NVIC_SHCSR_SVCALLACT             0x00000080
N#define  CPU_REG_NVIC_SHCSR_USGFAULTACT           0x00000008
N#define  CPU_REG_NVIC_SHCSR_BUSFAULTACT           0x00000002
N#define  CPU_REG_NVIC_SHCSR_MEMFAULTACT           0x00000001
N
N                                                                /* -------- CONFIGURABLE FAULT STATUS REG BITS -------- */
N#define  CPU_REG_NVIC_CFSR_DIVBYZERO              0x02000000
N#define  CPU_REG_NVIC_CFSR_UNALIGNED              0x01000000
N#define  CPU_REG_NVIC_CFSR_NOCP                   0x00080000
N#define  CPU_REG_NVIC_CFSR_INVPC                  0x00040000
N#define  CPU_REG_NVIC_CFSR_INVSTATE               0x00020000
N#define  CPU_REG_NVIC_CFSR_UNDEFINSTR             0x00010000
N#define  CPU_REG_NVIC_CFSR_BFARVALID              0x00008000
N#define  CPU_REG_NVIC_CFSR_STKERR                 0x00001000
N#define  CPU_REG_NVIC_CFSR_UNSTKERR               0x00000800
N#define  CPU_REG_NVIC_CFSR_IMPRECISERR            0x00000400
N#define  CPU_REG_NVIC_CFSR_PRECISERR              0x00000200
N#define  CPU_REG_NVIC_CFSR_IBUSERR                0x00000100
N#define  CPU_REG_NVIC_CFSR_MMARVALID              0x00000080
N#define  CPU_REG_NVIC_CFSR_MSTKERR                0x00000010
N#define  CPU_REG_NVIC_CFSR_MUNSTKERR              0x00000008
N#define  CPU_REG_NVIC_CFSR_DACCVIOL               0x00000002
N#define  CPU_REG_NVIC_CFSR_IACCVIOL               0x00000001
N
N                                                                /* ------------ HARD FAULT STATUS REG BITS ------------ */
N#define  CPU_REG_NVIC_HFSR_DEBUGEVT               0x80000000
N#define  CPU_REG_NVIC_HFSR_FORCED                 0x40000000
N#define  CPU_REG_NVIC_HFSR_VECTTBL                0x00000002
N
N                                                                /* ------------ DEBUG FAULT STATUS REG BITS ----------- */
N#define  CPU_REG_NVIC_DFSR_EXTERNAL               0x00000010
N#define  CPU_REG_NVIC_DFSR_VCATCH                 0x00000008
N#define  CPU_REG_NVIC_DFSR_DWTTRAP                0x00000004
N#define  CPU_REG_NVIC_DFSR_BKPT                   0x00000002
N#define  CPU_REG_NVIC_DFSR_HALTED                 0x00000001
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          CPU REGISTER MASK
N*********************************************************************************************************
N*/
N
N#define  CPU_MSK_NVIC_ICSR_VECT_ACTIVE            0x000001FF
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_CFG_ADDR_SIZE
S#error  "CPU_CFG_ADDR_SIZE              not #define'd in 'cpu.h'               "
S#error  "                         [MUST be  CPU_WORD_SIZE_08   8-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_16  16-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_32  32-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_64  64-bit alignment]"
S
S#elif  ((CPU_CFG_ADDR_SIZE != CPU_WORD_SIZE_08) && \
S        (CPU_CFG_ADDR_SIZE != CPU_WORD_SIZE_16) && \
S        (CPU_CFG_ADDR_SIZE != CPU_WORD_SIZE_32) && \
S        (CPU_CFG_ADDR_SIZE != CPU_WORD_SIZE_64))
X#elif  ((4 != 1) &&         (4 != 2) &&         (4 != 4) &&         (4 != 8))
S#error  "CPU_CFG_ADDR_SIZE        illegally #define'd in 'cpu.h'               "
S#error  "                         [MUST be  CPU_WORD_SIZE_08   8-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_16  16-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_32  32-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_64  64-bit alignment]"
N#endif
N
N
N#ifndef  CPU_CFG_DATA_SIZE
S#error  "CPU_CFG_DATA_SIZE              not #define'd in 'cpu.h'               "
S#error  "                         [MUST be  CPU_WORD_SIZE_08   8-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_16  16-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_32  32-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_64  64-bit alignment]"
S
S#elif  ((CPU_CFG_DATA_SIZE != CPU_WORD_SIZE_08) && \
S        (CPU_CFG_DATA_SIZE != CPU_WORD_SIZE_16) && \
S        (CPU_CFG_DATA_SIZE != CPU_WORD_SIZE_32) && \
S        (CPU_CFG_DATA_SIZE != CPU_WORD_SIZE_64))
X#elif  ((4 != 1) &&         (4 != 2) &&         (4 != 4) &&         (4 != 8))
S#error  "CPU_CFG_DATA_SIZE        illegally #define'd in 'cpu.h'               "
S#error  "                         [MUST be  CPU_WORD_SIZE_08   8-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_16  16-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_32  32-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_64  64-bit alignment]"
N#endif
N
N
N#ifndef  CPU_CFG_DATA_SIZE_MAX
S#error  "CPU_CFG_DATA_SIZE_MAX          not #define'd in 'cpu.h'               "
S#error  "                         [MUST be  CPU_WORD_SIZE_08   8-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_16  16-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_32  32-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_64  64-bit alignment]"
S
S#elif  ((CPU_CFG_DATA_SIZE_MAX != CPU_WORD_SIZE_08) && \
S        (CPU_CFG_DATA_SIZE_MAX != CPU_WORD_SIZE_16) && \
S        (CPU_CFG_DATA_SIZE_MAX != CPU_WORD_SIZE_32) && \
S        (CPU_CFG_DATA_SIZE_MAX != CPU_WORD_SIZE_64))
X#elif  ((8 != 1) &&         (8 != 2) &&         (8 != 4) &&         (8 != 8))
S#error  "CPU_CFG_DATA_SIZE_MAX    illegally #define'd in 'cpu.h'               "
S#error  "                         [MUST be  CPU_WORD_SIZE_08   8-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_16  16-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_32  32-bit alignment]"
S#error  "                         [     ||  CPU_WORD_SIZE_64  64-bit alignment]"
N#endif
N
N
N
N#if     (CPU_CFG_DATA_SIZE_MAX < CPU_CFG_DATA_SIZE)
X#if     (8 < 4)
S#error  "CPU_CFG_DATA_SIZE_MAX    illegally #define'd in 'cpu.h' "
S#error  "                         [MUST be  >= CPU_CFG_DATA_SIZE]"
N#endif
N
N
N
N
N/*$PAGE*/
N#ifndef  CPU_CFG_ENDIAN_TYPE
S#error  "CPU_CFG_ENDIAN_TYPE            not #define'd in 'cpu.h'   "
S#error  "                         [MUST be  CPU_ENDIAN_TYPE_BIG   ]"
S#error  "                         [     ||  CPU_ENDIAN_TYPE_LITTLE]"
S
S#elif  ((CPU_CFG_ENDIAN_TYPE != CPU_ENDIAN_TYPE_BIG   ) && \
S        (CPU_CFG_ENDIAN_TYPE != CPU_ENDIAN_TYPE_LITTLE))
X#elif  ((2u != 1u   ) &&         (2u != 2u))
S#error  "CPU_CFG_ENDIAN_TYPE      illegally #define'd in 'cpu.h'   "
S#error  "                         [MUST be  CPU_ENDIAN_TYPE_BIG   ]"
S#error  "                         [     ||  CPU_ENDIAN_TYPE_LITTLE]"
N#endif
N
N
N
N
N#ifndef  CPU_CFG_STK_GROWTH
S#error  "CPU_CFG_STK_GROWTH             not #define'd in 'cpu.h'    "
S#error  "                         [MUST be  CPU_STK_GROWTH_LO_TO_HI]"
S#error  "                         [     ||  CPU_STK_GROWTH_HI_TO_LO]"
S
S#elif  ((CPU_CFG_STK_GROWTH != CPU_STK_GROWTH_LO_TO_HI) && \
S        (CPU_CFG_STK_GROWTH != CPU_STK_GROWTH_HI_TO_LO))
X#elif  ((2u != 1u) &&         (2u != 2u))
S#error  "CPU_CFG_STK_GROWTH       illegally #define'd in 'cpu.h'    "
S#error  "                         [MUST be  CPU_STK_GROWTH_LO_TO_HI]"
S#error  "                         [     ||  CPU_STK_GROWTH_HI_TO_LO]"
N#endif
N
N
N
N
N#ifndef  CPU_CFG_CRITICAL_METHOD
S#error  "CPU_CFG_CRITICAL_METHOD        not #define'd in 'cpu.h'             "
S#error  "                         [MUST be  CPU_CRITICAL_METHOD_INT_DIS_EN  ]"
S#error  "                         [     ||  CPU_CRITICAL_METHOD_STATUS_STK  ]"
S#error  "                         [     ||  CPU_CRITICAL_METHOD_STATUS_LOCAL]"
S
S#elif  ((CPU_CFG_CRITICAL_METHOD != CPU_CRITICAL_METHOD_INT_DIS_EN  ) && \
S        (CPU_CFG_CRITICAL_METHOD != CPU_CRITICAL_METHOD_STATUS_STK  ) && \
S        (CPU_CFG_CRITICAL_METHOD != CPU_CRITICAL_METHOD_STATUS_LOCAL))
X#elif  ((3u != 1u  ) &&         (3u != 2u  ) &&         (3u != 3u))
S#error  "CPU_CFG_CRITICAL_METHOD  illegally #define'd in 'cpu.h'             "
S#error  "                         [MUST be  CPU_CRITICAL_METHOD_INT_DIS_EN  ]"
S#error  "                         [     ||  CPU_CRITICAL_METHOD_STATUS_STK  ]"
S#error  "                         [     ||  CPU_CRITICAL_METHOD_STATUS_LOCAL]"
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*
N* Note(s) : (1) See 'cpu.h  MODULE'.
N*********************************************************************************************************
N*/
N
N#endif                                                          /* End of CPU module include.                           */
N
L 105 "..\..\uCOS-III\uC-CPU\cpu_core.h" 2
N#include  <lib_def.h>
L 1 "..\..\uCOS-III\uC-LIB\lib_def.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/LIB
N*                                        CUSTOM LIBRARY MODULES
N*
N*                          (c) Copyright 2004-2012; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/LIB is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                     CORE CUSTOM LIBRARY MODULE
N*
N* Filename      : lib_def.h
N* Version       : V1.37.01
N* Programmer(s) : ITJ
N*                 FBJ
N*********************************************************************************************************
N* Note(s)       : (1) Assumes the following versions (or more recent) of software modules are included in
N*                     the project build :
N*
N*                     (a) uC/CPU V1.29.00
N*
N*
N*                 (2) NO compiler-supplied standard library functions are used in library or product software.
N*
N*                     (a) ALL standard library functions are implemented in the custom library modules :
N*
N*                         (1) \<Custom Library Directory>\lib_*.*
N*
N*                         (2) \<Custom Library Directory>\Ports\<cpu>\<compiler>\lib*_a.*
N*
N*                               where
N*                                       <Custom Library Directory>      directory path for custom library software
N*                                       <cpu>                           directory name for specific processor (CPU)
N*                                       <compiler>                      directory name for specific compiler
N*
N*                     (b) Product-specific library functions are implemented in individual products.
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*
N* Note(s) : (1) This library definition header file is protected from multiple pre-processor inclusion
N*               through use of the library definition module present pre-processor macro definition.
N*********************************************************************************************************
N*/
N
N#ifndef  LIB_DEF_MODULE_PRESENT
N#define  LIB_DEF_MODULE_PRESENT
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                CUSTOM LIBRARY MODULE VERSION NUMBER
N*
N* Note(s) : (1) (a) The custom library module software version is denoted as follows :
N*
N*                       Vx.yy.zz
N*
N*                           where
N*                                   V               denotes 'Version' label
N*                                   x               denotes     major software version revision number
N*                                   yy              denotes     minor software version revision number
N*                                   zz              denotes sub-minor software version revision number
N*
N*               (b) The software version label #define is formatted as follows :
N*
N*                       ver = x.yyzz * 100 * 100
N*
N*                           where
N*                                   ver             denotes software version number scaled as an integer value
N*                                   x.yyzz          denotes software version number, where the unscaled integer
N*                                                       portion denotes the major version number & the unscaled
N*                                                       fractional portion denotes the (concatenated) minor
N*                                                       version numbers
N*********************************************************************************************************
N*/
N
N#define  LIB_VERSION                                   13700u   /* See Note #1.                                         */
N
N
N/*
N*********************************************************************************************************
N*                                            INCLUDE FILES
N*
N* Note(s) : (1) The custom library software files are located in the following directories :
N*
N*               (a) \<Custom Library Directory>\lib_*.*
N*
N*                       where
N*                               <Custom Library Directory>      directory path for custom library software
N*
N*           (2) CPU-configuration  software files are located in the following directories :
N*
N*               (a) \<CPU-Compiler Directory>\cpu_*.*
N*               (b) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*
N*
N*                       where
N*                               <CPU-Compiler Directory>        directory path for common CPU-compiler software
N*                               <cpu>                           directory name for specific processor (CPU)
N*                               <compiler>                      directory name for specific compiler
N*
N*           (3) Compiler MUST be configured to include as additional include path directories :
N*
N*               (a) '\<Custom Library Directory>\' directory                            See Note #1a
N*
N*               (b) (1) '\<CPU-Compiler Directory>\'                  directory         See Note #2a
N*                   (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory         See Note #2b
N*********************************************************************************************************
N*/
N
N#include  <cpu_def.h>
N#include  <cpu.h>
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          STANDARD DEFINES
N*********************************************************************************************************
N*/
N
N#define  DEF_NULL                                 ((void *)0)
N
N
N                                                                /* ----------------- BOOLEAN DEFINES ------------------ */
N#define  DEF_FALSE                                         0u
N#define  DEF_TRUE                                          1u
N
N#define  DEF_NO                                            0u
N#define  DEF_YES                                           1u
N
N#define  DEF_DISABLED                                      0u
N#define  DEF_ENABLED                                       1u
N
N#define  DEF_INACTIVE                                      0u
N#define  DEF_ACTIVE                                        1u
N
N#define  DEF_INVALID                                       0u
N#define  DEF_VALID                                         1u
N
N#define  DEF_OFF                                           0u
N#define  DEF_ON                                            1u
N
N#define  DEF_CLR                                           0u
N#define  DEF_SET                                           1u
N
N#define  DEF_FAIL                                          0u
N#define  DEF_OK                                            1u
N
N
N                                                                /* ------------------- BIT DEFINES -------------------- */
N#define  DEF_BIT_NONE                                   0x00u
N
N#define  DEF_BIT_00                                     0x01u
N#define  DEF_BIT_01                                     0x02u
N#define  DEF_BIT_02                                     0x04u
N#define  DEF_BIT_03                                     0x08u
N#define  DEF_BIT_04                                     0x10u
N#define  DEF_BIT_05                                     0x20u
N#define  DEF_BIT_06                                     0x40u
N#define  DEF_BIT_07                                     0x80u
N
N#define  DEF_BIT_08                                   0x0100u
N#define  DEF_BIT_09                                   0x0200u
N#define  DEF_BIT_10                                   0x0400u
N#define  DEF_BIT_11                                   0x0800u
N#define  DEF_BIT_12                                   0x1000u
N#define  DEF_BIT_13                                   0x2000u
N#define  DEF_BIT_14                                   0x4000u
N#define  DEF_BIT_15                                   0x8000u
N
N#define  DEF_BIT_16                               0x00010000u
N#define  DEF_BIT_17                               0x00020000u
N#define  DEF_BIT_18                               0x00040000u
N#define  DEF_BIT_19                               0x00080000u
N#define  DEF_BIT_20                               0x00100000u
N#define  DEF_BIT_21                               0x00200000u
N#define  DEF_BIT_22                               0x00400000u
N#define  DEF_BIT_23                               0x00800000u
N
N#define  DEF_BIT_24                               0x01000000u
N#define  DEF_BIT_25                               0x02000000u
N#define  DEF_BIT_26                               0x04000000u
N#define  DEF_BIT_27                               0x08000000u
N#define  DEF_BIT_28                               0x10000000u
N#define  DEF_BIT_29                               0x20000000u
N#define  DEF_BIT_30                               0x40000000u
N#define  DEF_BIT_31                               0x80000000u
N/*$PAGE*/
N#define  DEF_BIT_32                       0x0000000100000000u
N#define  DEF_BIT_33                       0x0000000200000000u
N#define  DEF_BIT_34                       0x0000000400000000u
N#define  DEF_BIT_35                       0x0000000800000000u
N#define  DEF_BIT_36                       0x0000001000000000u
N#define  DEF_BIT_37                       0x0000002000000000u
N#define  DEF_BIT_38                       0x0000004000000000u
N#define  DEF_BIT_39                       0x0000008000000000u
N
N#define  DEF_BIT_40                       0x0000010000000000u
N#define  DEF_BIT_41                       0x0000020000000000u
N#define  DEF_BIT_42                       0x0000040000000000u
N#define  DEF_BIT_43                       0x0000080000000000u
N#define  DEF_BIT_44                       0x0000100000000000u
N#define  DEF_BIT_45                       0x0000200000000000u
N#define  DEF_BIT_46                       0x0000400000000000u
N#define  DEF_BIT_47                       0x0000800000000000u
N
N#define  DEF_BIT_48                       0x0001000000000000u
N#define  DEF_BIT_49                       0x0002000000000000u
N#define  DEF_BIT_50                       0x0004000000000000u
N#define  DEF_BIT_51                       0x0008000000000000u
N#define  DEF_BIT_52                       0x0010000000000000u
N#define  DEF_BIT_53                       0x0020000000000000u
N#define  DEF_BIT_54                       0x0040000000000000u
N#define  DEF_BIT_55                       0x0080000000000000u
N
N#define  DEF_BIT_56                       0x0100000000000000u
N#define  DEF_BIT_57                       0x0200000000000000u
N#define  DEF_BIT_58                       0x0400000000000000u
N#define  DEF_BIT_59                       0x0800000000000000u
N#define  DEF_BIT_60                       0x1000000000000000u
N#define  DEF_BIT_61                       0x2000000000000000u
N#define  DEF_BIT_62                       0x4000000000000000u
N#define  DEF_BIT_63                       0x8000000000000000u
N
N
N                                                                /* ------------------ ALIGN DEFINES ------------------- */
N#define  DEF_ALIGN_MAX_NBR_OCTETS                       4096u
N
N
N                                                                /* ------------------ OCTET DEFINES ------------------- */
N#define  DEF_OCTET_NBR_BITS                                8u
N#define  DEF_OCTET_MASK                                 0xFFu
N
N#define  DEF_OCTET_TO_BIT_NBR_BITS                         3u
N#define  DEF_OCTET_TO_BIT_SHIFT                          DEF_OCTET_TO_BIT_NBR_BITS
N#define  DEF_OCTET_TO_BIT_MASK                          0x07u
N
N
N#define  DEF_NIBBLE_NBR_BITS                               4u
N#define  DEF_NIBBLE_MASK                                0x0Fu
N
N
N                                                                /* --------------- NUMBER BASE DEFINES ---------------- */
N#define  DEF_NBR_BASE_BIN                                  2u
N#define  DEF_NBR_BASE_OCT                                  8u
N#define  DEF_NBR_BASE_DEC                                 10u
N#define  DEF_NBR_BASE_HEX                                 16u
N
N
N/*$PAGE*/
N                                                                /* ----------------- INTEGER DEFINES ------------------ */
N#define  DEF_INT_08_NBR_BITS                               8u
N#define  DEF_INT_08_MASK                                0xFFu
N
N#define  DEF_INT_08U_MIN_VAL                               0u
N#define  DEF_INT_08U_MAX_VAL                             255u
N
N#define  DEF_INT_08S_MIN_VAL_ONES_CPL                  (-127)
N#define  DEF_INT_08S_MAX_VAL_ONES_CPL                    127
N
N#define  DEF_INT_08S_MIN_VAL                            (DEF_INT_08S_MIN_VAL_ONES_CPL - 1)
N#define  DEF_INT_08S_MAX_VAL                             DEF_INT_08S_MAX_VAL_ONES_CPL
N
N#define  DEF_INT_08U_NBR_DIG_MIN                           1u
N#define  DEF_INT_08U_NBR_DIG_MAX                           3u
N
N#define  DEF_INT_08S_NBR_DIG_MIN                           3u
N#define  DEF_INT_08S_NBR_DIG_MAX                           3u
N
N
N
N#define  DEF_INT_16_NBR_BITS                              16u
N#define  DEF_INT_16_MASK                              0xFFFFu
N
N#define  DEF_INT_16U_MIN_VAL                               0u
N#define  DEF_INT_16U_MAX_VAL                           65535u
N
N#define  DEF_INT_16S_MIN_VAL_ONES_CPL                (-32767)
N#define  DEF_INT_16S_MAX_VAL_ONES_CPL                  32767
N
N#define  DEF_INT_16S_MIN_VAL                            (DEF_INT_16S_MIN_VAL_ONES_CPL - 1)
N#define  DEF_INT_16S_MAX_VAL                             DEF_INT_16S_MAX_VAL_ONES_CPL
N
N#define  DEF_INT_16U_NBR_DIG_MIN                           1u
N#define  DEF_INT_16U_NBR_DIG_MAX                           5u
N
N#define  DEF_INT_16S_NBR_DIG_MIN                           5u
N#define  DEF_INT_16S_NBR_DIG_MAX                           5u
N
N
N
N#define  DEF_INT_32_NBR_BITS                              32u
N#define  DEF_INT_32_MASK                          0xFFFFFFFFu
N
N#define  DEF_INT_32U_MIN_VAL                               0u
N#define  DEF_INT_32U_MAX_VAL                      4294967295u
N
N#define  DEF_INT_32S_MIN_VAL_ONES_CPL           (-2147483647)
N#define  DEF_INT_32S_MAX_VAL_ONES_CPL             2147483647
N
N#define  DEF_INT_32S_MIN_VAL                            (DEF_INT_32S_MIN_VAL_ONES_CPL - 1)
N#define  DEF_INT_32S_MAX_VAL                             DEF_INT_32S_MAX_VAL_ONES_CPL
N
N#define  DEF_INT_32U_NBR_DIG_MIN                           1u
N#define  DEF_INT_32U_NBR_DIG_MAX                          10u
N
N#define  DEF_INT_32S_NBR_DIG_MIN                          10u
N#define  DEF_INT_32S_NBR_DIG_MAX                          10u
N
N
N
N#define  DEF_INT_64_NBR_BITS                              64u
N#define  DEF_INT_64_MASK                  0xFFFFFFFFFFFFFFFFu
N
N#define  DEF_INT_64U_MIN_VAL                               0u
N#define  DEF_INT_64U_MAX_VAL            18446744073709551615u
N
N#define  DEF_INT_64S_MIN_VAL_ONES_CPL  (-9223372036854775807)
N#define  DEF_INT_64S_MAX_VAL_ONES_CPL    9223372036854775807
N
N#define  DEF_INT_64S_MIN_VAL                            (DEF_INT_64S_MIN_VAL_ONES_CPL - 1)
N#define  DEF_INT_64S_MAX_VAL                             DEF_INT_64S_MAX_VAL_ONES_CPL
N
N#define  DEF_INT_64U_NBR_DIG_MIN                           1u
N#define  DEF_INT_64U_NBR_DIG_MAX                          20u
N
N#define  DEF_INT_64S_NBR_DIG_MIN                          19u
N#define  DEF_INT_64S_NBR_DIG_MAX                          19u
N
N
N
N/*$PAGE*/
N                                                                /* --------------- CPU INTEGER DEFINES ---------------- */
N#define  DEF_INT_CPU_NBR_BITS                           (CPU_CFG_DATA_SIZE     * DEF_OCTET_NBR_BITS)
N#define  DEF_INT_CPU_NBR_BITS_MAX                       (CPU_CFG_DATA_SIZE_MAX * DEF_OCTET_NBR_BITS)
N
N
N
N#if     (DEF_INT_CPU_NBR_BITS == DEF_INT_08_NBR_BITS)
X#if     ((4 * 8u) == 8u)
S
S
S#define  DEF_INT_CPU_MASK                                DEF_INT_08_MASK
S
S#define  DEF_INT_CPU_U_MIN_VAL                           DEF_INT_08U_MIN_VAL
S#define  DEF_INT_CPU_U_MAX_VAL                           DEF_INT_08U_MAX_VAL
S
S#define  DEF_INT_CPU_S_MIN_VAL                           DEF_INT_08S_MIN_VAL
S#define  DEF_INT_CPU_S_MAX_VAL                           DEF_INT_08S_MAX_VAL
S
S#define  DEF_INT_CPU_S_MIN_VAL_ONES_CPL                  DEF_INT_08S_MIN_VAL_ONES_CPL
S#define  DEF_INT_CPU_S_MAX_VAL_ONES_CPL                  DEF_INT_08S_MAX_VAL_ONES_CPL
S
S
S
S#elif   (DEF_INT_CPU_NBR_BITS == DEF_INT_16_NBR_BITS)
X#elif   ((4 * 8u) == 16u)
S
S
S#define  DEF_INT_CPU_MASK                                DEF_INT_16_MASK
S
S#define  DEF_INT_CPU_U_MIN_VAL                           DEF_INT_16U_MIN_VAL
S#define  DEF_INT_CPU_U_MAX_VAL                           DEF_INT_16U_MAX_VAL
S
S#define  DEF_INT_CPU_S_MIN_VAL                           DEF_INT_16S_MIN_VAL
S#define  DEF_INT_CPU_S_MAX_VAL                           DEF_INT_16S_MAX_VAL
S
S#define  DEF_INT_CPU_S_MIN_VAL_ONES_CPL                  DEF_INT_16S_MIN_VAL_ONES_CPL
S#define  DEF_INT_CPU_S_MAX_VAL_ONES_CPL                  DEF_INT_16S_MAX_VAL_ONES_CPL
S
S
S
N#elif   (DEF_INT_CPU_NBR_BITS == DEF_INT_32_NBR_BITS)
X#elif   ((4 * 8u) == 32u)
N
N
N#define  DEF_INT_CPU_MASK                                DEF_INT_32_MASK
N
N#define  DEF_INT_CPU_U_MIN_VAL                           DEF_INT_32U_MIN_VAL
N#define  DEF_INT_CPU_U_MAX_VAL                           DEF_INT_32U_MAX_VAL
N
N#define  DEF_INT_CPU_S_MIN_VAL                           DEF_INT_32S_MIN_VAL
N#define  DEF_INT_CPU_S_MAX_VAL                           DEF_INT_32S_MAX_VAL
N
N#define  DEF_INT_CPU_S_MIN_VAL_ONES_CPL                  DEF_INT_32S_MIN_VAL_ONES_CPL
N#define  DEF_INT_CPU_S_MAX_VAL_ONES_CPL                  DEF_INT_32S_MAX_VAL_ONES_CPL
N
N
N
N#elif   (DEF_INT_CPU_NBR_BITS == DEF_INT_64_NBR_BITS)
S
S
S#define  DEF_INT_CPU_MASK                                DEF_INT_64_MASK
S
S#define  DEF_INT_CPU_U_MIN_VAL                           DEF_INT_64U_MIN_VAL
S#define  DEF_INT_CPU_U_MAX_VAL                           DEF_INT_64U_MAX_VAL
S
S#define  DEF_INT_CPU_S_MIN_VAL                           DEF_INT_64S_MIN_VAL
S#define  DEF_INT_CPU_S_MAX_VAL                           DEF_INT_64S_MAX_VAL
S
S#define  DEF_INT_CPU_S_MIN_VAL_ONES_CPL                  DEF_INT_64S_MIN_VAL_ONES_CPL
S#define  DEF_INT_CPU_S_MAX_VAL_ONES_CPL                  DEF_INT_64S_MAX_VAL_ONES_CPL
S
S
S
S#else
S
S#error  "CPU_CFG_DATA_SIZE  illegally #defined in 'cpu.h'      "
S#error  "                   [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N
N/*$PAGE*/
N                                                                /* ------------------- TIME DEFINES ------------------- */
N#define  DEF_TIME_NBR_DAY_PER_WK                           7u
N#define  DEF_TIME_NBR_DAY_PER_YR                         365u
N#define  DEF_TIME_NBR_DAY_PER_YR_LEAP                    366u
N
N#define  DEF_TIME_NBR_HR_PER_DAY                          24u
N#define  DEF_TIME_NBR_HR_PER_WK                         (DEF_TIME_NBR_HR_PER_DAY  * DEF_TIME_NBR_DAY_PER_WK     )
N#define  DEF_TIME_NBR_HR_PER_YR                         (DEF_TIME_NBR_HR_PER_DAY  * DEF_TIME_NBR_DAY_PER_YR     )
N#define  DEF_TIME_NBR_HR_PER_YR_LEAP                    (DEF_TIME_NBR_HR_PER_DAY  * DEF_TIME_NBR_DAY_PER_YR_LEAP)
N
N#define  DEF_TIME_NBR_MIN_PER_HR                          60u
N#define  DEF_TIME_NBR_MIN_PER_DAY                       (DEF_TIME_NBR_MIN_PER_HR  * DEF_TIME_NBR_HR_PER_DAY     )
N#define  DEF_TIME_NBR_MIN_PER_WK                        (DEF_TIME_NBR_MIN_PER_DAY * DEF_TIME_NBR_DAY_PER_WK     )
N#define  DEF_TIME_NBR_MIN_PER_YR                        (DEF_TIME_NBR_MIN_PER_DAY * DEF_TIME_NBR_DAY_PER_YR     )
N#define  DEF_TIME_NBR_MIN_PER_YR_LEAP                   (DEF_TIME_NBR_MIN_PER_DAY * DEF_TIME_NBR_DAY_PER_YR_LEAP)
N
N#define  DEF_TIME_NBR_SEC_PER_MIN                         60u
N#define  DEF_TIME_NBR_SEC_PER_HR                        (DEF_TIME_NBR_SEC_PER_MIN * DEF_TIME_NBR_MIN_PER_HR     )
N#define  DEF_TIME_NBR_SEC_PER_DAY                       (DEF_TIME_NBR_SEC_PER_HR  * DEF_TIME_NBR_HR_PER_DAY     )
N#define  DEF_TIME_NBR_SEC_PER_WK                        (DEF_TIME_NBR_SEC_PER_DAY * DEF_TIME_NBR_DAY_PER_WK     )
N#define  DEF_TIME_NBR_SEC_PER_YR                        (DEF_TIME_NBR_SEC_PER_DAY * DEF_TIME_NBR_DAY_PER_YR     )
N#define  DEF_TIME_NBR_SEC_PER_YR_LEAP                   (DEF_TIME_NBR_SEC_PER_DAY * DEF_TIME_NBR_DAY_PER_YR_LEAP)
N
N#define  DEF_TIME_NBR_mS_PER_SEC                        1000u
N#define  DEF_TIME_NBR_uS_PER_SEC                     1000000u
N#define  DEF_TIME_NBR_nS_PER_SEC                  1000000000u
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             ERROR CODES
N*
N* Note(s) : (1) All library error codes are #define'd in 'lib_def.h';
N*********************************************************************************************************
N*/
N
Ntypedef enum lib_err {
N
N    LIB_ERR_NONE                            =         0u,
N
N    LIB_MEM_ERR_NONE                        =     10000u,
N    LIB_MEM_ERR_NULL_PTR                    =     10001u,       /* Ptr arg(s) passed NULL ptr(s).                       */
N
N    LIB_MEM_ERR_INVALID_MEM_SIZE            =     10100u,       /* Invalid mem     size.                                */
N    LIB_MEM_ERR_INVALID_MEM_ALIGN           =     10101u,       /* Invalid mem     align.                               */
N    LIB_MEM_ERR_INVALID_SEG_SIZE            =     10110u,       /* Invalid mem seg size.                                */
N    LIB_MEM_ERR_INVALID_SEG_OVERLAP         =     10111u,       /* Invalid mem seg overlaps other mem seg(s).           */
N    LIB_MEM_ERR_INVALID_POOL                =     10120u,       /* Invalid mem pool.                                    */
N    LIB_MEM_ERR_INVALID_BLK_NBR             =     10130u,       /* Invalid mem pool blk nbr.                            */
N    LIB_MEM_ERR_INVALID_BLK_SIZE            =     10131u,       /* Invalid mem pool blk size.                           */
N    LIB_MEM_ERR_INVALID_BLK_ALIGN           =     10132u,       /* Invalid mem pool blk align.                          */
N    LIB_MEM_ERR_INVALID_BLK_IX              =     10133u,       /* Invalid mem pool ix.                                 */
N    LIB_MEM_ERR_INVALID_BLK_ADDR            =     10135u,       /* Invalid mem pool blk addr.                           */
N    LIB_MEM_ERR_INVALID_BLK_ADDR_IN_POOL    =     10136u,       /* Mem pool blk addr already in mem pool.               */
N
N    LIB_MEM_ERR_SEG_EMPTY                   =     10200u,       /* Mem seg  empty; i.e. NO avail mem in seg.            */
N    LIB_MEM_ERR_SEG_OVF                     =     10201u,       /* Mem seg  ovf;   i.e. req'd mem ovfs rem mem in seg.  */
N    LIB_MEM_ERR_POOL_FULL                   =     10205u,       /* Mem pool full;  i.e. all mem blks avail in mem pool. */
N    LIB_MEM_ERR_POOL_EMPTY                  =     10206u,       /* Mem pool empty; i.e. NO  mem blks avail in mem pool. */
N
N    LIB_MEM_ERR_HEAP_EMPTY                  =     10210u,       /* Heap seg empty; i.e. NO avail mem in heap.           */
N    LIB_MEM_ERR_HEAP_OVF                    =     10211u,       /* Heap seg ovf;   i.e. req'd mem ovfs rem mem in heap. */
N    LIB_MEM_ERR_HEAP_NOT_FOUND              =     10215u        /* Heap seg NOT found.                                  */
N
N} LIB_ERR;
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             DATA TYPES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                          GLOBAL VARIABLES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               TRACING
N*********************************************************************************************************
N*/
N
N                                                                /* Trace level, default to TRACE_LEVEL_OFF.             */
N#ifndef  TRACE_LEVEL_OFF
N#define  TRACE_LEVEL_OFF                                   0u
N#endif
N
N#ifndef  TRACE_LEVEL_INFO
N#define  TRACE_LEVEL_INFO                                  1u
N#endif
N
N#ifndef  TRACE_LEVEL_DBG
N#define  TRACE_LEVEL_DBG                                   2u
N#endif
N
N#ifndef  TRACE_LEVEL_LOG
N#define  TRACE_LEVEL_LOG                                   3u
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             BIT MACRO'S
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                              DEF_BIT()
N*
N* Description : Create bit mask with single, specified bit set.
N*
N* Argument(s) : bit         Bit number of bit to set.
N*
N* Return(s)   : Bit mask with single, specified bit set.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'bit' SHOULD be a non-negative integer.
N*
N*               (2) (a) 'bit' values that overflow the target CPU &/or compiler environment (e.g. negative
N*                       or greater-than-CPU-data-size values) MAY generate compiler warnings &/or errors.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT(bit)                                                   (1u << (bit))
N
N
N/*
N*********************************************************************************************************
N*                                             DEF_BITxx()
N*
N* Description : Create bit mask of specified bit size with single, specified bit set.
N*
N* Argument(s) : bit         Bit number of bit to set.
N*
N* Return(s)   : Bit mask with single, specified bit set.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'bit' SHOULD be a non-negative integer.
N*
N*               (2) (a) 'bit' values that overflow the target CPU &/or compiler environment (e.g. negative
N*                       or greater-than-CPU-data-size values) MAY generate compiler warnings &/or errors.
N*
N*                   (b) To avoid overflowing any target CPU &/or compiler's integer data type, unsigned
N*                       bit constant '1' is cast to specified integer data type size.
N*
N*               (3) Ideally, DEF_BITxx() macro's should be named DEF_BIT_xx(); however, these names already
N*                   previously-released for bit constant #define's (see 'STANDARD DEFINES  BIT DEFINES').
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT08(bit)                        ((CPU_INT08U)((CPU_INT08U)1u  << (bit)))
N
N#define  DEF_BIT16(bit)                        ((CPU_INT16U)((CPU_INT16U)1u  << (bit)))
N
N#define  DEF_BIT32(bit)                        ((CPU_INT32U)((CPU_INT32U)1u  << (bit)))
N
N#define  DEF_BIT64(bit)                        ((CPU_INT64U)((CPU_INT64U)1u  << (bit)))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                           DEF_BIT_MASK()
N*
N* Description : Shift a bit mask.
N*
N* Argument(s) : bit_mask    Bit mask to shift.
N*
N*               bit_shift   Number of bit positions to left-shift bit mask.
N*
N* Return(s)   : Shifted bit mask.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) 'bit_mask'  SHOULD be an unsigned    integer.
N*
N*                   (b) 'bit_shift' SHOULD be a non-negative integer.
N*
N*               (2) 'bit_shift' values that overflow the target CPU &/or compiler environment (e.g. negative
N*                   or greater-than-CPU-data-size values) MAY generate compiler warnings &/or errors.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_MASK(bit_mask, bit_shift)                                     ((bit_mask) << (bit_shift))
N
N
N/*
N*********************************************************************************************************
N*                                          DEF_BIT_MASK_xx()
N*
N* Description : Shift a bit mask of specified bit size.
N*
N* Argument(s) : bit_mask    Bit mask to shift.
N*
N*               bit_shift   Number of bit positions to left-shift bit mask.
N*
N* Return(s)   : Shifted bit mask.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) 'bit_mask'  SHOULD be an unsigned    integer.
N*
N*                   (b) 'bit_shift' SHOULD be a non-negative integer.
N*
N*               (2) 'bit_shift' values that overflow the target CPU &/or compiler environment (e.g. negative
N*                   or greater-than-CPU-data-size values) MAY generate compiler warnings &/or errors.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_MASK_08(bit_mask, bit_shift)         ((CPU_INT08U)((CPU_INT08U)(bit_mask) << (bit_shift)))
N
N#define  DEF_BIT_MASK_16(bit_mask, bit_shift)         ((CPU_INT16U)((CPU_INT16U)(bit_mask) << (bit_shift)))
N
N#define  DEF_BIT_MASK_32(bit_mask, bit_shift)         ((CPU_INT32U)((CPU_INT32U)(bit_mask) << (bit_shift)))
N
N#define  DEF_BIT_MASK_64(bit_mask, bit_shift)         ((CPU_INT64U)((CPU_INT64U)(bit_mask) << (bit_shift)))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                           DEF_BIT_FIELD()
N*
N* Description : Create & shift a contiguous bit field.
N*
N* Argument(s) : bit_field   Number of contiguous bits to set in the bit field.
N*
N*               bit_shift   Number of bit positions   to left-shift bit field.
N*
N* Return(s)   : Shifted bit field.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'bit_field' & 'bit_shift' SHOULD be non-negative integers.
N*
N*               (2) (a) 'bit_field'/'bit_shift' values that overflow the target CPU &/or compiler
N*                       environment (e.g. negative or greater-than-CPU-data-size values) MAY generate
N*                       compiler warnings &/or errors.
N*
N*                   (b) To avoid overflowing any target CPU &/or compiler's integer data type, unsigned
N*                       bit constant '1' is suffixed with 'L'ong integer modifier.
N*
N*                       This may still be insufficient for CPUs &/or compilers that support 'long long'
N*                       integer data types, in which case 'LL' integer modifier should be suffixed.
N*                       However, since almost all 16- & 32-bit CPUs & compilers support 'long' integer
N*                       data types but many may NOT support 'long long' integer data types, only 'long'
N*                       integer data types & modifiers are supported.
N*
N*                       See also 'DEF_BIT_FIELD_xx()  Note #1b'.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_FIELD(bit_field, bit_shift)                                 ((((bit_field) >= DEF_INT_CPU_NBR_BITS) ? (DEF_INT_CPU_U_MAX_VAL)     \
N                                                                                                                     : (DEF_BIT(bit_field) - 1uL)) \
N                                                                                                                            << (bit_shift))
X#define  DEF_BIT_FIELD(bit_field, bit_shift)                                 ((((bit_field) >= DEF_INT_CPU_NBR_BITS) ? (DEF_INT_CPU_U_MAX_VAL)                                                                                                                          : (DEF_BIT(bit_field) - 1uL))                                                                                                                             << (bit_shift))
N
N/*
N*********************************************************************************************************
N*                                         DEF_BIT_FIELD_xx()
N*
N* Description : Create & shift a contiguous bit field of specified bit size.
N*
N* Argument(s) : bit_field   Number of contiguous bits to set in the bit field.
N*
N*               bit_shift   Number of bit positions   to left-shift bit field.
N*
N* Return(s)   : Shifted bit field.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'bit_field' & 'bit_shift' SHOULD be non-negative integers.
N*
N*               (2) (a) 'bit_field'/'bit_shift' values that overflow the target CPU &/or compiler
N*                       environment (e.g. negative or greater-than-CPU-data-size values) MAY generate
N*                       compiler warnings &/or errors.
N*
N*                   (b) To avoid overflowing any target CPU &/or compiler's integer data type, unsigned
N*                       bit constant '1' is cast to specified integer data type size.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_FIELD_08(bit_field, bit_shift)     ((CPU_INT08U)((((CPU_INT08U)(bit_field) >= (CPU_INT08U)DEF_INT_08_NBR_BITS) ? (CPU_INT08U)(DEF_INT_08U_MAX_VAL)                    \
N                                                                                                                                : (CPU_INT08U)(DEF_BIT08(bit_field) - (CPU_INT08U)1u)) \
N                                                                                                                                                     << (bit_shift)))
X#define  DEF_BIT_FIELD_08(bit_field, bit_shift)     ((CPU_INT08U)((((CPU_INT08U)(bit_field) >= (CPU_INT08U)DEF_INT_08_NBR_BITS) ? (CPU_INT08U)(DEF_INT_08U_MAX_VAL)                                                                                                                                                    : (CPU_INT08U)(DEF_BIT08(bit_field) - (CPU_INT08U)1u))                                                                                                                                                      << (bit_shift)))
N
N#define  DEF_BIT_FIELD_16(bit_field, bit_shift)     ((CPU_INT16U)((((CPU_INT16U)(bit_field) >= (CPU_INT16U)DEF_INT_16_NBR_BITS) ? (CPU_INT16U)(DEF_INT_16U_MAX_VAL)                    \
N                                                                                                                                : (CPU_INT16U)(DEF_BIT16(bit_field) - (CPU_INT16U)1u)) \
N                                                                                                                                                     << (bit_shift)))
X#define  DEF_BIT_FIELD_16(bit_field, bit_shift)     ((CPU_INT16U)((((CPU_INT16U)(bit_field) >= (CPU_INT16U)DEF_INT_16_NBR_BITS) ? (CPU_INT16U)(DEF_INT_16U_MAX_VAL)                                                                                                                                                    : (CPU_INT16U)(DEF_BIT16(bit_field) - (CPU_INT16U)1u))                                                                                                                                                      << (bit_shift)))
N
N#define  DEF_BIT_FIELD_32(bit_field, bit_shift)     ((CPU_INT32U)((((CPU_INT32U)(bit_field) >= (CPU_INT32U)DEF_INT_32_NBR_BITS) ? (CPU_INT32U)(DEF_INT_32U_MAX_VAL)                    \
N                                                                                                                                : (CPU_INT32U)(DEF_BIT32(bit_field) - (CPU_INT32U)1u)) \
N                                                                                                                                                     << (bit_shift)))
X#define  DEF_BIT_FIELD_32(bit_field, bit_shift)     ((CPU_INT32U)((((CPU_INT32U)(bit_field) >= (CPU_INT32U)DEF_INT_32_NBR_BITS) ? (CPU_INT32U)(DEF_INT_32U_MAX_VAL)                                                                                                                                                    : (CPU_INT32U)(DEF_BIT32(bit_field) - (CPU_INT32U)1u))                                                                                                                                                      << (bit_shift)))
N
N#define  DEF_BIT_FIELD_64(bit_field, bit_shift)     ((CPU_INT64U)((((CPU_INT64U)(bit_field) >= (CPU_INT64U)DEF_INT_64_NBR_BITS) ? (CPU_INT64U)(DEF_INT_64U_MAX_VAL)                    \
N                                                                                                                                : (CPU_INT64U)(DEF_BIT64(bit_field) - (CPU_INT64U)1u)) \
N                                                                                                                                                     << (bit_shift)))
X#define  DEF_BIT_FIELD_64(bit_field, bit_shift)     ((CPU_INT64U)((((CPU_INT64U)(bit_field) >= (CPU_INT64U)DEF_INT_64_NBR_BITS) ? (CPU_INT64U)(DEF_INT_64U_MAX_VAL)                                                                                                                                                    : (CPU_INT64U)(DEF_BIT64(bit_field) - (CPU_INT64U)1u))                                                                                                                                                      << (bit_shift)))
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          DEF_BIT_SET_xx()
N*
N* Description : Set specified bit(s) in a value of specified bit size.
N*
N* Argument(s) : val         Value to modify by setting specified bit(s).
N*
N*               mask        Mask of bits to set.
N*
N* Return(s)   : Modified value with specified bit(s) set.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'val' & 'mask' SHOULD be unsigned integers.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_SET_08(val, mask)                     ((val) = (CPU_INT08U)(((CPU_INT08U)(val)) | ((CPU_INT08U) (mask))))
N
N#define  DEF_BIT_SET_16(val, mask)                     ((val) = (CPU_INT16U)(((CPU_INT16U)(val)) | ((CPU_INT16U) (mask))))
N
N#define  DEF_BIT_SET_32(val, mask)                     ((val) = (CPU_INT32U)(((CPU_INT32U)(val)) | ((CPU_INT32U) (mask))))
N
N#define  DEF_BIT_SET_64(val, mask)                     ((val) = (CPU_INT64U)(((CPU_INT64U)(val)) | ((CPU_INT64U) (mask))))
N
N
N/*
N*********************************************************************************************************
N*                                            DEF_BIT_SET()
N*
N* Description : Set specified bit(s) in a value.
N*
N* Argument(s) : val         Value to modify by setting specified bit(s).
N*
N*               mask        Mask of bits to set.
N*
N* Return(s)   : Modified value with specified bit(s) set.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'val' & 'mask' SHOULD be unsigned integers.
N*********************************************************************************************************
N*/
N
N#if     (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_08)
X#if     (8 == 1)
S
S#define  DEF_BIT_SET(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_SET_08(val, mask) : 0)
S
S
S#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_16)
X#elif   (8 == 2)
S
S#define  DEF_BIT_SET(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_SET_08(val, mask) :   \
S                                                ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_SET_16(val, mask) : 0))
X#define  DEF_BIT_SET(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_SET_08(val, mask) :                                                   ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_SET_16(val, mask) : 0))
S
S
S#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_32)
X#elif   (8 == 4)
S
S#define  DEF_BIT_SET(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_SET_08(val, mask) :    \
S                                                ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_SET_16(val, mask) :    \
S                                                ((sizeof(val) == CPU_WORD_SIZE_32) ? DEF_BIT_SET_32(val, mask) : 0)))
X#define  DEF_BIT_SET(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_SET_08(val, mask) :                                                    ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_SET_16(val, mask) :                                                    ((sizeof(val) == CPU_WORD_SIZE_32) ? DEF_BIT_SET_32(val, mask) : 0)))
S
S
N#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_64)
X#elif   (8 == 8)
N
N#define  DEF_BIT_SET(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_SET_08(val, mask) :     \
N                                                ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_SET_16(val, mask) :     \
N                                                ((sizeof(val) == CPU_WORD_SIZE_32) ? DEF_BIT_SET_32(val, mask) :     \
N                                                ((sizeof(val) == CPU_WORD_SIZE_64) ? DEF_BIT_SET_64(val, mask) : 0))))
X#define  DEF_BIT_SET(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_SET_08(val, mask) :                                                     ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_SET_16(val, mask) :                                                     ((sizeof(val) == CPU_WORD_SIZE_32) ? DEF_BIT_SET_32(val, mask) :                                                     ((sizeof(val) == CPU_WORD_SIZE_64) ? DEF_BIT_SET_64(val, mask) : 0))))
N
N#else
S
S#error  "CPU_CFG_DATA_SIZE_MAX  illegally #defined in 'cpu.h'      "
S#error  "                       [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          DEF_BIT_CLR_xx()
N*
N* Description : Clear specified bit(s) in a value of specified bit size.
N*
N* Argument(s) : val         Value to modify by clearing specified bit(s).
N*
N*               mask        Mask of bits to clear.
N*
N* Return(s)   : Modified value with specified bit(s) clear.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'val' & 'mask' SHOULD be unsigned integers.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_CLR_08(val, mask)                     ((val) = (CPU_INT08U)(((CPU_INT08U)(val)) & ((CPU_INT08U)~(mask))))
N
N#define  DEF_BIT_CLR_16(val, mask)                     ((val) = (CPU_INT16U)(((CPU_INT16U)(val)) & ((CPU_INT16U)~(mask))))
N
N#define  DEF_BIT_CLR_32(val, mask)                     ((val) = (CPU_INT32U)(((CPU_INT32U)(val)) & ((CPU_INT32U)~(mask))))
N
N#define  DEF_BIT_CLR_64(val, mask)                     ((val) = (CPU_INT64U)(((CPU_INT64U)(val)) & ((CPU_INT64U)~(mask))))
N
N
N/*
N*********************************************************************************************************
N*                                            DEF_BIT_CLR()
N*
N* Description : Clear specified bit(s) in a value.
N*
N* Argument(s) : val         Value to modify by clearing specified bit(s).
N*
N*               mask        Mask of bits to clear.
N*
N* Return(s)   : Modified value with specified bit(s) clear.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'val' & 'mask' SHOULD be unsigned integers.
N*********************************************************************************************************
N*/
N
N#if     (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_08)
X#if     (8 == 1)
S
S#define  DEF_BIT_CLR(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08(val, mask) : 0)
S
S
S#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_16)
X#elif   (8 == 2)
S
S#define  DEF_BIT_CLR(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08(val, mask) :   \
S                                                ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16(val, mask) : 0))
X#define  DEF_BIT_CLR(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08(val, mask) :                                                   ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16(val, mask) : 0))
S
S
S#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_32)
X#elif   (8 == 4)
S
S#define  DEF_BIT_CLR(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08(val, mask) :    \
S                                                ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16(val, mask) :    \
S                                                ((sizeof(val) == CPU_WORD_SIZE_32) ? DEF_BIT_CLR_32(val, mask) : 0)))
X#define  DEF_BIT_CLR(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08(val, mask) :                                                    ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16(val, mask) :                                                    ((sizeof(val) == CPU_WORD_SIZE_32) ? DEF_BIT_CLR_32(val, mask) : 0)))
S
S
N#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_64)
X#elif   (8 == 8)
N
N#define  DEF_BIT_CLR(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08(val, mask) :     \
N                                                ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16(val, mask) :     \
N                                                ((sizeof(val) == CPU_WORD_SIZE_32) ? DEF_BIT_CLR_32(val, mask) :     \
N                                                ((sizeof(val) == CPU_WORD_SIZE_64) ? DEF_BIT_CLR_64(val, mask) : 0))))
X#define  DEF_BIT_CLR(val, mask)                 ((sizeof(val) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08(val, mask) :                                                     ((sizeof(val) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16(val, mask) :                                                     ((sizeof(val) == CPU_WORD_SIZE_32) ? DEF_BIT_CLR_32(val, mask) :                                                     ((sizeof(val) == CPU_WORD_SIZE_64) ? DEF_BIT_CLR_64(val, mask) : 0))))
N
N#else
S
S#error  "CPU_CFG_DATA_SIZE_MAX  illegally #defined in 'cpu.h'      "
S#error  "                       [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          DEF_BIT_IS_SET()
N*
N* Description : Determine if specified bit(s) in a value are set.
N*
N* Argument(s) : val         Value to check for specified bit(s) set.
N*
N*               mask        Mask of bits to check if set (see Note #2).
N*
N* Return(s)   : DEF_YES, if ALL specified bit(s) are     set in value.
N*
N*               DEF_NO,  if ALL specified bit(s) are NOT set in value.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'val' & 'mask' SHOULD be unsigned integers.
N*
N*               (2) NULL 'mask' allowed; returns 'DEF_NO' since NO mask bits specified.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_IS_SET(val, mask)                           ((((mask)  !=  0u)  && \
N                                                      (((val) & (mask)) == (mask))) ? (DEF_YES) : (DEF_NO ))
X#define  DEF_BIT_IS_SET(val, mask)                           ((((mask)  !=  0u)  &&                                                       (((val) & (mask)) == (mask))) ? (DEF_YES) : (DEF_NO ))
N
N
N/*
N*********************************************************************************************************
N*                                          DEF_BIT_IS_CLR()
N*
N* Description : Determine if specified bit(s) in a value are clear.
N*
N* Argument(s) : val         Value to check for specified bit(s) clear.
N*
N*               mask        Mask of bits to check if clear (see Note #2).
N*
N* Return(s)   : DEF_YES, if ALL specified bit(s) are     clear in value.
N*
N*               DEF_NO,  if ALL specified bit(s) are NOT clear in value.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'val' & 'mask' SHOULD be unsigned integers.
N*
N*               (2) NULL 'mask' allowed; returns 'DEF_NO' since NO mask bits specified.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_IS_CLR(val, mask)                           ((((mask)  !=  0u)  && \
N                                                      (((val) & (mask)) ==  0u))    ? (DEF_YES) : (DEF_NO ))
X#define  DEF_BIT_IS_CLR(val, mask)                           ((((mask)  !=  0u)  &&                                                       (((val) & (mask)) ==  0u))    ? (DEF_YES) : (DEF_NO ))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        DEF_BIT_IS_SET_ANY()
N*
N* Description : Determine if any specified bit(s) in a value are set.
N*
N* Argument(s) : val         Value to check for specified bit(s) set.
N*
N*               mask        Mask of bits to check if set (see Note #2).
N*
N* Return(s)   : DEF_YES, if ANY specified bit(s) are     set in value.
N*
N*               DEF_NO,  if ALL specified bit(s) are NOT set in value.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'val' & 'mask' SHOULD be unsigned integers.
N*
N*               (2) NULL 'mask' allowed; returns 'DEF_NO' since NO mask bits specified.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_IS_SET_ANY(val, mask)               ((((val) & (mask)) ==  0u)     ? (DEF_NO ) : (DEF_YES))
N
N
N/*
N*********************************************************************************************************
N*                                        DEF_BIT_IS_CLR_ANY()
N*
N* Description : Determine if any specified bit(s) in a value are clear.
N*
N* Argument(s) : val         Value to check for specified bit(s) clear.
N*
N*               mask        Mask of bits to check if clear (see Note #2).
N*
N* Return(s)   : DEF_YES, if ANY specified bit(s) are     clear in value.
N*
N*               DEF_NO,  if ALL specified bit(s) are NOT clear in value.
N*
N* Note(s)     : (1) 'val' & 'mask' SHOULD be unsigned integers.
N*
N*               (2) NULL 'mask' allowed; returns 'DEF_NO' since NO mask bits specified.
N*********************************************************************************************************
N*/
N
N#define  DEF_BIT_IS_CLR_ANY(val, mask)               ((((val) & (mask)) == (mask))  ? (DEF_NO ) : (DEF_YES))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                            VALUE MACRO'S
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                          DEF_CHK_VAL_MIN()
N*
N* Description : Validate a value as greater than or equal to a specified minimum value.
N*
N* Argument(s) : val        Value to validate.
N*
N*               val_min    Minimum value to test.
N*
N* Return(s)   : DEF_OK,    Value is greater than or equal to minimum value.
N*
N*               DEF_FAIL,  otherwise.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) DEF_CHK_VAL_MIN() avoids directly comparing any two values if only one of the values
N*                   is negative since the negative value might be incorrectly promoted to an arbitrary
N*                   unsigned value if the other value to compare is unsigned.
N*
N*               (2) Validation of values is limited to the range supported by the compiler &/or target
N*                   environment.  All other values that underflow/overflow the supported range will
N*                   modulo/wrap into the supported range as arbitrary signed or unsigned values.
N*
N*                   Therefore, any values that underflow the most negative signed value or overflow
N*                   the most positive unsigned value supported by the compiler &/or target environment
N*                   cannot be validated :
N*
N*                           (    N-1       N     ]
N*                           ( -(2   )  ,  2  - 1 ]
N*                           (                    ]
N*
N*                               where
N*                                       N       Number of data word bits supported by the compiler
N*                                                   &/or target environment
N*
N*                   (a) Note that the most negative value, -2^(N-1), is NOT included in the supported
N*                       range since many compilers do NOT always correctly handle this value.
N*
N*               (3) 'val' and 'val_min' are compared to 1 instead of 0 to avoid warning generated for
N*                   unsigned numbers.
N*********************************************************************************************************
N*/
N
N#define  DEF_CHK_VAL_MIN(val, val_min)            (((!(((val)     >= 1) && ((val_min) < 1))) && \
N                                                     ((((val_min) >= 1) && ((val)     < 1))  || \
N                                                       ((val) < (val_min)))) ? DEF_FAIL : DEF_OK)
X#define  DEF_CHK_VAL_MIN(val, val_min)            (((!(((val)     >= 1) && ((val_min) < 1))) &&                                                      ((((val_min) >= 1) && ((val)     < 1))  ||                                                        ((val) < (val_min)))) ? DEF_FAIL : DEF_OK)
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          DEF_CHK_VAL_MAX()
N*
N* Description : Validate a value as less than or equal to a specified maximum value.
N*
N* Argument(s) : val        Value to validate.
N*
N*               val_max    Maximum value to test.
N*
N* Return(s)   : DEF_OK,    Value is less than or equal to maximum value.
N*
N*               DEF_FAIL,  otherwise.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) DEF_CHK_VAL_MAX() avoids directly comparing any two values if only one of the values
N*                   is negative since the negative value might be incorrectly promoted to an arbitrary
N*                   unsigned value if the other value to compare is unsigned.
N*
N*               (2) Validation of values is limited to the range supported by the compiler &/or target
N*                   environment.  All other values that underflow/overflow the supported range will
N*                   modulo/wrap into the supported range as arbitrary signed or unsigned values.
N*
N*                   Therefore, any values that underflow the most negative signed value or overflow
N*                   the most positive unsigned value supported by the compiler &/or target environment
N*                   cannot be validated :
N*
N*                           (    N-1       N     ]
N*                           ( -(2   )  ,  2  - 1 ]
N*                           (                    ]
N*
N*                               where
N*                                       N       Number of data word bits supported by the compiler
N*                                                   &/or target environment
N*
N*                   (a) Note that the most negative value, -2^(N-1), is NOT included in the supported
N*                       range since many compilers do NOT always correctly handle this value.
N*
N*               (3) 'val' and 'val_max' are compared to 1 instead of 0 to avoid warning generated for
N*                   unsigned numbers.
N*********************************************************************************************************
N*/
N
N#define  DEF_CHK_VAL_MAX(val, val_max)            (((!(((val_max) >= 1) && ((val)     < 1))) && \
N                                                     ((((val)     >= 1) && ((val_max) < 1))  || \
N                                                       ((val) > (val_max)))) ? DEF_FAIL : DEF_OK)
X#define  DEF_CHK_VAL_MAX(val, val_max)            (((!(((val_max) >= 1) && ((val)     < 1))) &&                                                      ((((val)     >= 1) && ((val_max) < 1))  ||                                                        ((val) > (val_max)))) ? DEF_FAIL : DEF_OK)
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                            DEF_CHK_VAL()
N*
N* Description : Validate a value as greater than or equal to a specified minimum value & less than or
N*                   equal to a specified maximum value.
N*
N* Argument(s) : val        Value to validate.
N*
N*               val_min    Minimum value to test.
N*
N*               val_max    Maximum value to test.
N*
N* Return(s)   : DEF_OK,    Value is greater than or equal to minimum value AND
N*                                   less    than or equal to maximum value.
N*
N*               DEF_FAIL,  otherwise.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) DEF_CHK_VAL() avoids directly comparing any two values if only one of the values
N*                   is negative since the negative value might be incorrectly promoted to an arbitrary
N*                   unsigned value if the other value to compare is unsigned.
N*
N*               (2) Validation of values is limited to the range supported by the compiler &/or target
N*                   environment.  All other values that underflow/overflow the supported range will
N*                   modulo/wrap into the supported range as arbitrary signed or unsigned values.
N*
N*                   Therefore, any values that underflow the most negative signed value or overflow
N*                   the most positive unsigned value supported by the compiler &/or target environment
N*                   cannot be validated :
N*
N*                           (    N-1       N     ]
N*                           ( -(2   )  ,  2  - 1 ]
N*                           (                    ]
N*
N*                               where
N*                                       N       Number of data word bits supported by the compiler
N*                                                   &/or target environment
N*
N*                   (a) Note that the most negative value, -2^(N-1), is NOT included in the supported
N*                       range since many compilers do NOT always correctly handle this value.
N*
N*               (3) DEF_CHK_VAL() does NOT validate that the maximum value ('val_max') is greater than
N*                   or equal to the minimum value ('val_min').
N*********************************************************************************************************
N*/
N
N#define  DEF_CHK_VAL(val, val_min, val_max)          (((DEF_CHK_VAL_MIN(val, val_min) == DEF_FAIL) ||                  \
N                                                       (DEF_CHK_VAL_MAX(val, val_max) == DEF_FAIL)) ? DEF_FAIL : DEF_OK)
X#define  DEF_CHK_VAL(val, val_min, val_max)          (((DEF_CHK_VAL_MIN(val, val_min) == DEF_FAIL) ||                                                                         (DEF_CHK_VAL_MAX(val, val_max) == DEF_FAIL)) ? DEF_FAIL : DEF_OK)
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         DEF_GET_U_MAX_VAL()
N*
N* Description : Get the maximum unsigned value that can be represented in an unsigned integer variable
N*                   of the same data type size as an object.
N*
N* Argument(s) : obj         Object or data type to return maximum unsigned value (see Note #1).
N*
N* Return(s)   : Maximum unsigned integer value that can be represented by the object, if NO error(s).
N*
N*               0,                                                                    otherwise.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) 'obj' SHOULD be an integer object or data type but COULD also be a character or
N*                   pointer object or data type.
N*********************************************************************************************************
N*/
N
N#if     (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_08)
X#if     (8 == 1)
S
S#define  DEF_GET_U_MAX_VAL(obj)                 ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL : 0)
S
S
S#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_16)
X#elif   (8 == 2)
S
S#define  DEF_GET_U_MAX_VAL(obj)                 ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL :   \
S                                                ((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL : 0))
X#define  DEF_GET_U_MAX_VAL(obj)                 ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL :                                                   ((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL : 0))
S
S
S#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_32)
X#elif   (8 == 4)
S
S#define  DEF_GET_U_MAX_VAL(obj)                 ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL :    \
S                                                ((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL :    \
S                                                ((sizeof(obj) == CPU_WORD_SIZE_32) ? DEF_INT_32U_MAX_VAL : 0)))
X#define  DEF_GET_U_MAX_VAL(obj)                 ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL :                                                    ((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL :                                                    ((sizeof(obj) == CPU_WORD_SIZE_32) ? DEF_INT_32U_MAX_VAL : 0)))
S
S
N#elif   (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_64)
X#elif   (8 == 8)
N
N#define  DEF_GET_U_MAX_VAL(obj)                 ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL :     \
N                                                ((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL :     \
N                                                ((sizeof(obj) == CPU_WORD_SIZE_32) ? DEF_INT_32U_MAX_VAL :     \
N                                                ((sizeof(obj) == CPU_WORD_SIZE_64) ? DEF_INT_64U_MAX_VAL : 0))))
X#define  DEF_GET_U_MAX_VAL(obj)                 ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL :                                                     ((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL :                                                     ((sizeof(obj) == CPU_WORD_SIZE_32) ? DEF_INT_32U_MAX_VAL :                                                     ((sizeof(obj) == CPU_WORD_SIZE_64) ? DEF_INT_64U_MAX_VAL : 0))))
N
N#else
S
S#error  "CPU_CFG_DATA_SIZE_MAX  illegally #defined in 'cpu.h'      "
S#error  "                       [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                            MATH MACRO'S
N*
N* Note(s) : (1) Ideally, ALL mathematical macro's & functions SHOULD be defined in the custom mathematics
N*               library ('lib_math.*').  #### However, to maintain backwards compatibility with previously-
N*               released modules, mathematical macro & function definitions should only be moved to the
N*               custom mathematics library once all previously-released modules are updated to include the
N*               custom mathematics library.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                              DEF_MIN()
N*
N* Description : Determine the minimum of two values.
N*
N* Argument(s) : a           First  value.
N*
N*               b           Second value.
N*
N* Return(s)   : Minimum of the two values.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : none.
N*********************************************************************************************************
N*/
N
N#define  DEF_MIN(a, b)                                  (((a) < (b)) ? (a) : (b))
N
N
N/*
N*********************************************************************************************************
N*                                              DEF_MAX()
N*
N* Description : Determine the maximum of two values.
N*
N* Argument(s) : a           First  value.
N*
N*               b           Second value.
N*
N* Return(s)   : Maximum of the two values.
N*
N* Note(s)     : none.
N*********************************************************************************************************
N*/
N
N#define  DEF_MAX(a, b)                                  (((a) > (b)) ? (a) : (b))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                              DEF_ABS()
N*
N* Description : Determine the absolute value of a value.
N*
N* Argument(s) : a           Value to calculate absolute value.
N*
N* Return(s)   : Absolute value of the value.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : none.
N*********************************************************************************************************
N*/
N
N#define  DEF_ABS(a)                                     (((a) < 0) ? (-(a)) : (a))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         FUNCTION PROTOTYPES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                        CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                    LIBRARY CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N                                                                /* See 'lib_def.h  Note #1a'.                           */
N#if     (CPU_CORE_VERSION < 12900u)
X#if     (12901u < 12900u)
S#error  "CPU_CORE_VERSION  [SHOULD be >= V1.29.00]"
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*
N* Note(s) : (1) See 'lib_def.h  MODULE'.
N*********************************************************************************************************
N*/
N
N#endif                                                          /* End of lib def module include.                       */
N
L 106 "..\..\uCOS-III\uC-CPU\cpu_core.h" 2
N#include  <cpu_cfg.h>
N
N#if (CPU_CFG_NAME_EN == DEF_ENABLED)
X#if (1u == 1u)
N#include  <lib_mem.h>
L 1 "..\..\uCOS-III\uC-LIB\lib_mem.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/LIB
N*                                        CUSTOM LIBRARY MODULES
N*
N*                          (c) Copyright 2004-2012; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/LIB is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                     STANDARD MEMORY OPERATIONS
N*
N* Filename      : lib_mem.h
N* Version       : V1.37.01
N* Programmer(s) : ITJ
N*                 FBJ
N*********************************************************************************************************
N* Note(s)       : (1) NO compiler-supplied standard library functions are used in library or product software.
N*
N*                     (a) ALL standard library functions are implemented in the custom library modules :
N*
N*                         (1) \<Custom Library Directory>\lib_*.*
N*
N*                         (2) \<Custom Library Directory>\Ports\<cpu>\<compiler>\lib*_a.*
N*
N*                               where
N*                                       <Custom Library Directory>      directory path for custom library software
N*                                       <cpu>                           directory name for specific processor (CPU)
N*                                       <compiler>                      directory name for specific compiler
N*
N*                     (b) Product-specific library functions are implemented in individual products.
N*
N*                 (2) Assumes the following versions (or more recent) of software modules are included in
N*                     the project build :
N*
N*                     (a) uC/CPU V1.27
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*
N* Note(s) : (1) This memory library header file is protected from multiple pre-processor inclusion through
N*               use of the memory library module present pre-processor macro definition.
N*********************************************************************************************************
N*/
N
N#ifndef  LIB_MEM_MODULE_PRESENT                                 /* See Note #1.                                         */
N#define  LIB_MEM_MODULE_PRESENT
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                            INCLUDE FILES
N*
N* Note(s) : (1) The custom library software files are located in the following directories :
N*
N*               (a) \<Your Product Application>\lib_cfg.h
N*
N*               (b) \<Custom Library Directory>\lib_*.*
N*
N*                       where
N*                               <Your Product Application>      directory path for Your Product's Application
N*                               <Custom Library Directory>      directory path for custom library software
N*
N*           (2) CPU-configuration  software files are located in the following directories :
N*
N*               (a) \<CPU-Compiler Directory>\cpu_*.*
N*               (b) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*
N*
N*                       where
N*                               <CPU-Compiler Directory>        directory path for common CPU-compiler software
N*                               <cpu>                           directory name for specific processor (CPU)
N*                               <compiler>                      directory name for specific compiler
N*
N*           (3) Compiler MUST be configured to include as additional include path directories :
N*
N*               (a) '\<Your Product Application>\' directory                            See Note #1a
N*
N*               (b) '\<Custom Library Directory>\' directory                            See Note #1b
N*
N*               (c) (1) '\<CPU-Compiler Directory>\'                  directory         See Note #2a
N*                   (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory         See Note #2b
N*
N*           (4) NO compiler-supplied standard library functions SHOULD be used.
N*********************************************************************************************************
N*/
N
N#include  <cpu.h>
N#include  <cpu_core.h>
L 1 "..\..\uCOS-III\uC-CPU\cpu_core.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/CPU
N*                                    CPU CONFIGURATION & PORT LAYER
N*
N*                          (c) Copyright 2004-2011; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/CPU is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                           CORE CPU MODULE
N*
N* Filename      : cpu_core.h
N* Version       : V1.29.01
N* Programmer(s) : SR
N*                 ITJ
N*********************************************************************************************************
N* Note(s)       : (1) Assumes the following versions (or more recent) of software modules are included in
N*                     the project build :
N*
N*                     (a) uC/LIB V1.35.00
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*
N* Note(s) : (1) This core CPU header file is protected from multiple pre-processor inclusion through use of
N*               the  core CPU module present pre-processor macro definition.
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_CORE_MODULE_PRESENT                                /* See Note #1.                                         */
S#define  CPU_CORE_MODULE_PRESENT
S
S
S/*
S*********************************************************************************************************
S*                                               EXTERNS
S*********************************************************************************************************
S*/
S
S#ifdef   CPU_CORE_MODULE
S#define  CPU_CORE_EXT
S#else
S#define  CPU_CORE_EXT  extern
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                            INCLUDE FILES
S*
S* Note(s) : (1) CPU-configuration software files are located in the following directories :
S*
S*               (a) \<Your Product Application>\cpu_cfg.h
S*
S*               (b) (1) \<CPU-Compiler Directory>\cpu_*.*
S*                   (2) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*
S*
S*                       where
S*                               <Your Product Application>      directory path for Your Product's Application
S*                               <CPU-Compiler Directory>        directory path for common CPU-compiler software
S*                               <cpu>                           directory name for specific processor (CPU)
S*                               <compiler>                      directory name for specific compiler
S*
S*           (2) NO compiler-supplied standard library functions SHOULD be used.
S*
S*               (a) Standard library functions are implemented in the custom library module(s) :
S*
S*                       \<Custom Library Directory>\lib_*.*
S*
S*                           where
S*                                   <Custom Library Directory>      directory path for custom library software
S*
S*           (3) Compiler MUST be configured to include as additional include path directories :
S*
S*               (a) '\<Your Product Application>\' directory                            See Note #1a
S*
S*               (b) (1) '\<CPU-Compiler Directory>\'                  directory         See Note #1b1
S*                   (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory         See Note #1b2
S*
S*               (c) '\<Custom Library Directory>\' directory                            See Note #2a
S*********************************************************************************************************
S*/
S
S#include  <cpu.h>
S#include  <lib_def.h>
S#include  <cpu_cfg.h>
S
S#if (CPU_CFG_NAME_EN == DEF_ENABLED)
S#include  <lib_mem.h>
S#include  <lib_str.h>
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                          CPU CONFIGURATION
S*
S* Note(s) : (1) The following pre-processor directives correctly configure CPU parameters.  DO NOT MODIFY.
S*
S*           (2) CPU timestamp timer feature is required for :
S*
S*               (a) CPU timestamps
S*               (b) CPU interrupts disabled time measurement
S*
S*               See also 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
S*                      & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1'.
S*********************************************************************************************************
S*/
S
S#ifdef   CPU_CFG_TS_EN
S#undef   CPU_CFG_TS_EN
S#endif
S
S
S#if    ((CPU_CFG_TS_32_EN == DEF_ENABLED) || \
S        (CPU_CFG_TS_64_EN == DEF_ENABLED))
X#if    ((CPU_CFG_TS_32_EN == DEF_ENABLED) ||         (CPU_CFG_TS_64_EN == DEF_ENABLED))
S#define  CPU_CFG_TS_EN                          DEF_ENABLED
S#else
S#define  CPU_CFG_TS_EN                          DEF_DISABLED
S#endif
S
S#if    ((CPU_CFG_TS_EN == DEF_ENABLED) || \
S(defined(CPU_CFG_INT_DIS_MEAS_EN)))
X#if    ((CPU_CFG_TS_EN == DEF_ENABLED) || (defined(CPU_CFG_INT_DIS_MEAS_EN)))
S#define  CPU_CFG_TS_TMR_EN                      DEF_ENABLED
S#else
S#define  CPU_CFG_TS_TMR_EN                      DEF_DISABLED
S#endif
S
S
S/*
S*********************************************************************************************************
S*                                               DEFINES
S*********************************************************************************************************
S*/
S
S#define  CPU_TIME_MEAS_NBR_MIN                             1u
S#define  CPU_TIME_MEAS_NBR_MAX                           128u
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                             DATA TYPES
S*********************************************************************************************************
S*/
S
S
S/*
S*********************************************************************************************************
S*                                           CPU ERROR CODES
S*********************************************************************************************************
S*/
S
Stypedef enum cpu_err {
S
S    CPU_ERR_NONE                            =         0u,
S    CPU_ERR_NULL_PTR                        =        10u,
S
S    CPU_ERR_NAME_SIZE                       =      1000u,
S
S    CPU_ERR_TS_FREQ_INVALID                 =      2000u
S
S} CPU_ERR;
S
S
S/*
S*********************************************************************************************************
S*                                      CPU TIMESTAMP DATA TYPES
S*
S* Note(s) : (1) CPU timestamp timer data type defined to the binary-multiple of 8-bit octets as configured
S*               by 'CPU_CFG_TS_TMR_SIZE' (see 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #2').
S*********************************************************************************************************
S*/
S
Stypedef  CPU_INT32U  CPU_TS32;
Stypedef  CPU_INT64U  CPU_TS64;
S
Stypedef  CPU_TS32    CPU_TS;                                    /* Req'd for backwards-compatibility.                   */
S
S
S#if     (CPU_CFG_TS_TMR_EN   == DEF_ENABLED)                    /* CPU ts tmr defined to cfg'd word size (see Note #1). */
S#if     (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_08)
Stypedef  CPU_INT08U  CPU_TS_TMR;
S#elif   (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_16)
Stypedef  CPU_INT16U  CPU_TS_TMR;
S#elif   (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_64)
Stypedef  CPU_INT64U  CPU_TS_TMR;
S#else                                                           /* CPU ts tmr dflt size = 32-bits.                      */
Stypedef  CPU_INT32U  CPU_TS_TMR;
S#endif
S#endif
S
S
S/*
S*********************************************************************************************************
S*                               CPU TIMESTAMP TIMER FREQUENCY DATA TYPE
S*********************************************************************************************************
S*/
S
Stypedef  CPU_INT32U  CPU_TS_TMR_FREQ;
S
S
S/*
S*********************************************************************************************************
S*                                          GLOBAL VARIABLES
S*********************************************************************************************************
S*/
S
S#if    (CPU_CFG_NAME_EN   == DEF_ENABLED)
SCPU_CORE_EXT  CPU_CHAR         CPU_Name[CPU_CFG_NAME_SIZE];     /* CPU host name.                                       */
S#endif
S
S
S#if ((CPU_CFG_TS_32_EN    == DEF_ENABLED)  && \
S     (CPU_CFG_TS_TMR_SIZE <  CPU_WORD_SIZE_32))
X#if ((CPU_CFG_TS_32_EN    == DEF_ENABLED)  &&      (CPU_CFG_TS_TMR_SIZE <  CPU_WORD_SIZE_32))
SCPU_CORE_EXT  CPU_TS32         CPU_TS_32_Accum;                 /* 32-bit accum'd ts  (in ts tmr cnts).                 */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_TS_32_TmrPrev;               /* 32-bit ts prev tmr (in ts tmr cnts).                 */
S#endif
S
S#if ((CPU_CFG_TS_64_EN    == DEF_ENABLED)  && \
S     (CPU_CFG_TS_TMR_SIZE <  CPU_WORD_SIZE_64))
X#if ((CPU_CFG_TS_64_EN    == DEF_ENABLED)  &&      (CPU_CFG_TS_TMR_SIZE <  CPU_WORD_SIZE_64))
SCPU_CORE_EXT  CPU_TS64         CPU_TS_64_Accum;                 /* 64-bit accum'd ts  (in ts tmr cnts).                 */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_TS_64_TmrPrev;               /* 64-bit ts prev tmr (in ts tmr cnts).                 */
S#endif
S
S#if  (CPU_CFG_TS_TMR_EN   == DEF_ENABLED)
SCPU_CORE_EXT  CPU_TS_TMR_FREQ  CPU_TS_TmrFreq_Hz;               /* CPU ts tmr freq (in Hz).                             */
S#endif
S
S
S#ifdef  CPU_CFG_INT_DIS_MEAS_EN
SCPU_CORE_EXT  CPU_INT16U       CPU_IntDisMeasCtr;               /* Nbr tot    ints dis'd ctr.                           */
SCPU_CORE_EXT  CPU_INT16U       CPU_IntDisNestCtr;               /* Nbr nested ints dis'd ctr.                           */
S                                                                /* Ints dis'd time (in ts tmr cnts) : ...               */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasStart_cnts;        /* ...  start time.                                     */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasStop_cnts;         /* ...  stop  time.                                     */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasOvrhd_cnts;        /* ...        time meas ovrhd.                          */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasMaxCur_cnts;       /* ...     resetable max time dis'd.                    */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasMax_cnts;          /* ... non-resetable max time dis'd.                    */
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                               MACRO'S
S*********************************************************************************************************
S*/
S
S/*
S*********************************************************************************************************
S*                                         CPU_SW_EXCEPTION()
S*
S* Description : Trap unrecoverable software exception.
S*
S* Argument(s) : err_rtn_val     Error type &/or value of the calling function to return (see Note #2b).
S*
S* Return(s)   : none.
S*
S* Caller(s)   : various.
S*
S* Note(s)     : (1) CPU_SW_EXCEPTION() deadlocks the current code execution -- whether multi-tasked/
S*                   -processed/-threaded or single-threaded -- when the current code execution cannot
S*                   gracefully recover or report a fault or exception condition.
S*
S*                   Example CPU_SW_EXCEPTION() call :
S*
S*                       void  Fnct (CPU_ERR  *p_err)
S*                       {
S*                           :
S*
S*                           if (p_err == (CPU_ERR *)0) {        If 'p_err' NULL, cannot return error ...
S*                               CPU_SW_EXCEPTION(;);            ... so trap invalid argument exception.
S*                           }
S*
S*                           :
S*                       }
S*
S*                   See also 'cpu_core.c  CPU_SW_Exception()  Note #1'.
S*
S*               (2) (a) CPU_SW_EXCEPTION()  MAY be developer-implemented to output &/or handle any error or
S*                       exception conditions; but since CPU_SW_EXCEPTION() is intended to trap unrecoverable
S*                       software  conditions, it is recommended that developer-implemented versions prevent
S*                       execution of any code following calls to CPU_SW_EXCEPTION() by deadlocking the code
S*                       (see Note #1).
S*
S*                           Example CPU_SW_EXCEPTION() :
S*
S*                               #define  CPU_SW_EXCEPTION(err_rtn_val)      do {                         \
S*                                                                               Log(__FILE__, __LINE__); \
S*                                                                               CPU_SW_Exception();      \
S*                                                                           } while (0)
X
S*
S*                   (b) (1) However, if execution of code following calls to CPU_SW_EXCEPTION() is required
S*                           (e.g. for automated testing); it is recommended that the last statement in
S*                           developer-implemented versions be to return from the current function to prevent
S*                           possible software exception(s) in the current function from triggering CPU &/or
S*                           hardware exception(s).
S*
S*                           Example CPU_SW_EXCEPTION() :
S*
S*                               #define  CPU_SW_EXCEPTION(err_rtn_val)      do {                         \
S*                                                                               Log(__FILE__, __LINE__); \
S*                                                                               return  err_rtn_val;     \
S*                                                                           } while (0)
X
S*
S*                           (A) Note that 'err_rtn_val' in the return statement MUST NOT be enclosed in
S*                               parentheses.  This allows CPU_SW_EXCEPTION() to return from functions that
S*                               return 'void', i.e. NO return type or value (see also Note #2b2A).
S*$PAGE*
S*                       (2) In order for CPU_SW_EXCEPTION() to return from functions with various return
S*                           types/values, each caller function MUST pass an appropriate error return type
S*                           & value to CPU_SW_EXCEPTION().
S*
S*                           (A) Note that CPU_SW_EXCEPTION()  MUST NOT be passed any return type or value
S*                               for functions that return 'void', i.e. NO return type or value; but SHOULD
S*                               instead be passed a single semicolon.  This prevents possible compiler
S*                               warnings that CPU_SW_EXCEPTION() is passed too few arguments.  However,
S*                               the compiler may warn that CPU_SW_EXCEPTION() does NOT prevent creating
S*                               null statements on lines with NO other code statements.
S*
S*                           Example CPU_SW_EXCEPTION() calls :
S*
S*                               void  Fnct (CPU_ERR  *p_err)
S*                               {
S*                                   :
S*
S*                                   if (p_err == (CPU_ERR *)0) {
S*                                       CPU_SW_EXCEPTION(;);            Exception macro returns NO value
S*                                   }                                       (see Note #2b2A)
S*
S*                                   :
S*                               }
S*
S*                               CPU_BOOLEAN  Fnct (CPU_ERR  *p_err)
S*                               {
S*                                   :
S*
S*                                   if (p_err == (CPU_ERR *)0) {
S*                                       CPU_SW_EXCEPTION(DEF_FAIL);     Exception macro returns 'DEF_FAIL'
S*                                   }
S*
S*                                   :
S*                               }
S*
S*                               OBJ  *Fnct (CPU_ERR  *p_err)
S*                               {
S*                                   :
S*
S*                                   if (p_err == (CPU_ERR *)0) {
S*                                       CPU_SW_EXCEPTION((OBJ *)0);     Exception macro returns NULL 'OBJ *'
S*                                   }
S*
S*                                   :
S*                               }
S*
S*********************************************************************************************************
S*/
S
S#ifndef  CPU_SW_EXCEPTION                                                       /* See Note #2.                         */
S#define  CPU_SW_EXCEPTION(err_rtn_val)              do {                    \
S                                                        CPU_SW_Exception(); \
S                                                    } while (0)
X#define  CPU_SW_EXCEPTION(err_rtn_val)              do {                                                                            CPU_SW_Exception();                                                     } while (0)
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                           CPU_VAL_UNUSED()
S*
S* Description :
S*
S* Argument(s) : none.
S*
S* Return(s)   : none.
S*
S* Caller(s)   : #### various.
S*
S* Note(s)     : none.
S*********************************************************************************************************
S*/
S
S
S#define  CPU_VAL_UNUSED(val)        ((void)&(val));
S
S
S#define  CPU_VAL_IGNORED(val)       CPU_VAL_UNUSED(val)
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                          CPU_TYPE_CREATE()
S*
S* Description : Creates a generic type value.
S*
S* Argument(s) : char_1      1st ASCII character to create generic type value.
S*
S*               char_2      2nd ASCII character to create generic type value.
S*
S*               char_3      3rd ASCII character to create generic type value.
S*
S*               char_4      4th ASCII character to create generic type value.
S*
S* Return(s)   : 32-bit generic type value.
S*
S* Caller(s)   : various.
S*
S* Note(s)     : (1) (a) Generic type values should be #define'd with large, non-trivial values to trap
S*                       & discard invalid/corrupted objects based on type value.
S*
S*                       In other words, by assigning large, non-trivial values to valid objects' type
S*                       fields; the likelihood that an object with an unassigned &/or corrupted type
S*                       field will contain a value is highly improbable & therefore the object itself
S*                       will be trapped as invalid.
S*
S*                   (b) (1) CPU_TYPE_CREATE()  creates a 32-bit type value from four values.
S*
S*                       (2) Ideally, generic type values SHOULD be created from 'CPU_CHAR' characters to
S*                           represent ASCII string abbreviations of the specific object types.  Memory
S*                           displays of object type values will display the specific object types with
S*                           their chosen ASCII names.
S*
S*                           Examples :
S*
S*                               #define  FILE_TYPE  CPU_TYPE_CREATE('F', 'I', 'L', 'E')
S*                               #define  BUF_TYPE   CPU_TYPE_CREATE('B', 'U', 'F', ' ')
S*********************************************************************************************************
S*/
S
S#if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
S#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))
X#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))
S
S#else
S
S#if    ((CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_64) || \
S        (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_32))
X#if    ((CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_64) ||         (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_32))
S#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (0u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_2)) << (1u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_3)) << (2u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_4)) << (3u * DEF_OCTET_NBR_BITS)))
X#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (0u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (1u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (2u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (3u * DEF_OCTET_NBR_BITS)))
S
S
S#elif   (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_16)
S#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (2u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_2)) << (3u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_3)) << (0u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_4)) << (1u * DEF_OCTET_NBR_BITS)))
X#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (2u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (3u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (0u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (1u * DEF_OCTET_NBR_BITS)))
S
S#else                                                           /* Dflt CPU_WORD_SIZE_08.                               */
S#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))
X#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))
S#endif
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                         FUNCTION PROTOTYPES
S*
S* Note(s) : (1) CPU interrupts disabled time measurement functions prototyped/defined only if
S*               CPU_CFG_INT_DIS_MEAS_EN  #define'd in 'cpu_cfg.h'.
S*
S*           (2) (a) CPU_CntLeadZeros()  defined in :
S*
S*                   (1) 'cpu_a.asm',  if CPU_CFG_LEAD_ZEROS_ASM_PRESENT       #define'd in 'cpu.h'/
S*                                         'cpu_cfg.h' to enable assembly-optimized function(s)
S*
S*                   (2) 'cpu_core.c', if CPU_CFG_LEAD_ZEROS_ASM_PRESENT   NOT #define'd in 'cpu.h'/
S*                                         'cpu_cfg.h' to enable C-source-optimized function(s)
S*
S*               (b) CPU_CntTrailZeros() defined in :
S*
S*                   (1) 'cpu_a.asm',  if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT      #define'd in 'cpu.h'/
S*                                         'cpu_cfg.h' to enable assembly-optimized function(s)
S*
S*                   (2) 'cpu_core.c', if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT  NOT #define'd in 'cpu.h'/
S*                                         'cpu_cfg.h' to enable C-source-optimized function(s)
S*********************************************************************************************************
S*/
S
Svoid             CPU_Init                 (void);
S
Svoid             CPU_SW_Exception         (void);
S
S
S
S#if (CPU_CFG_NAME_EN == DEF_ENABLED)                                    /* -------------- CPU NAME FNCTS -------------- */
Svoid             CPU_NameClr              (void);
S
Svoid             CPU_NameGet              (       CPU_CHAR  *p_name,
S                                                  CPU_ERR   *p_err);
S
Svoid             CPU_NameSet              (const  CPU_CHAR  *p_name,
S                                                  CPU_ERR   *p_err);
S#endif
S
S
S
S                                                                        /* --------------- CPU TS FNCTS --------------- */
S#if (CPU_CFG_TS_32_EN == DEF_ENABLED)
SCPU_TS32         CPU_TS_Get32             (void);
S#endif
S
S#if (CPU_CFG_TS_64_EN == DEF_ENABLED)
SCPU_TS64         CPU_TS_Get64             (void);
S#endif
S
S#if (CPU_CFG_TS_EN    == DEF_ENABLED)
Svoid             CPU_TS_Update            (void);
S#endif
S
S
S#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)                                  /* ------------- CPU TS TMR FNCTS ------------- */
SCPU_TS_TMR_FREQ  CPU_TS_TmrFreqGet        (CPU_ERR          *p_err);
S
Svoid             CPU_TS_TmrFreqSet        (CPU_TS_TMR_FREQ   freq_hz);
S#endif
S
S
S
S#ifdef  CPU_CFG_INT_DIS_MEAS_EN                                         /* -------- CPU INT DIS TIME MEAS FNCTS ------- */
S                                                                        /* See Note #1.                                 */
SCPU_TS_TMR       CPU_IntDisMeasMaxCurReset(void);
S
SCPU_TS_TMR       CPU_IntDisMeasMaxCurGet  (void);
S
SCPU_TS_TMR       CPU_IntDisMeasMaxGet     (void);
S
S
Svoid             CPU_IntDisMeasStart      (void);
S
Svoid             CPU_IntDisMeasStop       (void);
S#endif
S
S
S
S                                                                        /* ----------- CPU CNT ZEROS FNCTS ------------ */
SCPU_DATA         CPU_CntLeadZeros         (CPU_DATA    val);
S
S#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_08)
SCPU_DATA         CPU_CntLeadZeros08       (CPU_INT08U  val);
S#endif
S#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_16)
SCPU_DATA         CPU_CntLeadZeros16       (CPU_INT16U  val);
S#endif
S#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_32)
SCPU_DATA         CPU_CntLeadZeros32       (CPU_INT32U  val);
S#endif
S#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_64)
SCPU_DATA         CPU_CntLeadZeros64       (CPU_INT64U  val);
S#endif
S
S
SCPU_DATA         CPU_CntTrailZeros        (CPU_DATA    val);
S
S#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_08)
SCPU_DATA         CPU_CntTrailZeros08      (CPU_INT08U  val);
S#endif
S#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_16)
SCPU_DATA         CPU_CntTrailZeros16      (CPU_INT16U  val);
S#endif
S#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_32)
SCPU_DATA         CPU_CntTrailZeros32      (CPU_INT32U  val);
S#endif
S#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_64)
SCPU_DATA         CPU_CntTrailZeros64      (CPU_INT64U  val);
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                         FUNCTION PROTOTYPES
S*                                      DEFINED IN PRODUCT'S BSP
S*********************************************************************************************************
S*/
S
S/*
S*********************************************************************************************************
S*                                          CPU_TS_TmrInit()
S*
S* Description : Initialize & start CPU timestamp timer.
S*
S* Argument(s) : none.
S*
S* Return(s)   : none.
S*
S* Caller(s)   : CPU_TS_Init().
S*
S*               This function is an INTERNAL CPU module function & MUST be implemented by application/
S*               BSP function(s) [see Note #1] but MUST NOT be called by application function(s).
S*
S* Note(s)     : (1) CPU_TS_TmrInit() is an application/BSP function that MUST be defined by the developer
S*                   if either of the following CPU features is enabled :
S*
S*                   (a) CPU timestamps
S*                   (b) CPU interrupts disabled time measurements
S*
S*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
S*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
S*
S*               (2) (a) Timer count values MUST be returned via word-size-configurable 'CPU_TS_TMR'
S*                       data type.
S*
S*                       (1) If timer has more bits, truncate timer values' higher-order bits greater
S*                           than the configured 'CPU_TS_TMR' timestamp timer data type word size.
S*
S*                       (2) Since the timer MUST NOT have less bits than the configured 'CPU_TS_TMR'
S*                           timestamp timer data type word size; 'CPU_CFG_TS_TMR_SIZE' MUST be
S*                           configured so that ALL bits in 'CPU_TS_TMR' data type are significant.
S*
S*                           In other words, if timer size is not a binary-multiple of 8-bit octets
S*                           (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple
S*                           octet word size SHOULD be configured (e.g. to 16-bits).  However, the
S*                           minimum supported word size for CPU timestamp timers is 8-bits.
S*
S*                       See also 'cpu_cfg.h   CPU TIMESTAMP CONFIGURATION  Note #2'
S*                              & 'cpu_core.h  CPU TIMESTAMP DATA TYPES     Note #1'.
S*
S*                   (b) Timer SHOULD be an 'up'  counter whose values increase with each time count.
S*
S*                   (c) When applicable, timer period SHOULD be less than the typical measured time
S*                       but MUST be less than the maximum measured time; otherwise, timer resolution
S*                       inadequate to measure desired times.
S*
S*                   See also 'CPU_TS_TmrRd()  Note #2'.
S*********************************************************************************************************
S*/
S
S#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
Svoid  CPU_TS_TmrInit(void);
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                           CPU_TS_TmrRd()
S*
S* Description : Get current CPU timestamp timer count value.
S*
S* Argument(s) : none.
S*
S* Return(s)   : Timestamp timer count (see Notes #2a & #2b).
S*
S* Caller(s)   : CPU_TS_Init(),
S*               CPU_TS_Get32(),
S*               CPU_TS_Get64(),
S*               CPU_IntDisMeasStart(),
S*               CPU_IntDisMeasStop().
S*
S*               This function is an INTERNAL CPU module function & MUST be implemented by application/
S*               BSP function(s) [see Note #1] but SHOULD NOT be called by application function(s).
S*
S* Note(s)     : (1) CPU_TS_TmrRd() is an application/BSP function that MUST be defined by the developer
S*                   if either of the following CPU features is enabled :
S*
S*                   (a) CPU timestamps
S*                   (b) CPU interrupts disabled time measurements
S*
S*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
S*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
S*
S*               (2) (a) Timer count values MUST be returned via word-size-configurable 'CPU_TS_TMR'
S*                       data type.
S*
S*                       (1) If timer has more bits, truncate timer values' higher-order bits greater
S*                           than the configured 'CPU_TS_TMR' timestamp timer data type word size.
S*
S*                       (2) Since the timer MUST NOT have less bits than the configured 'CPU_TS_TMR'
S*                           timestamp timer data type word size; 'CPU_CFG_TS_TMR_SIZE' MUST be
S*                           configured so that ALL bits in 'CPU_TS_TMR' data type are significant.
S*
S*                           In other words, if timer size is not a binary-multiple of 8-bit octets
S*                           (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple
S*                           octet word size SHOULD be configured (e.g. to 16-bits).  However, the
S*                           minimum supported word size for CPU timestamp timers is 8-bits.
S*
S*                       See also 'cpu_cfg.h   CPU TIMESTAMP CONFIGURATION  Note #2'
S*                              & 'cpu_core.h  CPU TIMESTAMP DATA TYPES     Note #1'.
S*
S*                   (b) Timer SHOULD be an 'up'  counter whose values increase with each time count.
S*
S*                       (1) If timer is a 'down' counter whose values decrease with each time count,
S*                           then the returned timer value MUST be ones-complemented.
S*
S*                   (c) (1) When applicable, the amount of time measured by CPU timestamps is
S*                           calculated by either of the following equations :
S*
S*                           (A) Time measured  =  Number timer counts  *  Timer period
S*
S*                                   where
S*
S*                                       Number timer counts     Number of timer counts measured
S*                                       Timer period            Timer's period in some units of
S*                                                                   (fractional) seconds
S*                                       Time measured           Amount of time measured, in same
S*                                                                   units of (fractional) seconds
S*                                                                   as the Timer period
S*
S*                                                  Number timer counts
S*                           (B) Time measured  =  ---------------------
S*                                                    Timer frequency
S*
S*                                   where
S*
S*                                       Number timer counts     Number of timer counts measured
S*                                       Timer frequency         Timer's frequency in some units
S*                                                                   of counts per second
S*                                       Time measured           Amount of time measured, in seconds
S*
S*                       (2) Timer period SHOULD be less than the typical measured time but MUST be less
S*                           than the maximum measured time; otherwise, timer resolution inadequate to
S*                           measure desired times.
S*********************************************************************************************************
S*/
S
S#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
SCPU_TS_TMR  CPU_TS_TmrRd(void);
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                         CPU_TSxx_to_uSec()
S*
S* Description : Convert a 32-/64-bit CPU timestamp from timer counts to microseconds.
S*
S* Argument(s) : ts_cnts   CPU timestamp (in timestamp timer counts [see Note #2aA]).
S*
S* Return(s)   : Converted CPU timestamp (in microseconds           [see Note #2aD]).
S*
S* Caller(s)   : Application.
S*
S*               This function is an (optional) CPU module application programming interface (API)
S*               function which MAY be implemented by application/BSP function(s) [see Note #1] &
S*               MAY be called by application function(s).
S*
S* Note(s)     : (1) CPU_TS32_to_uSec()/CPU_TS64_to_uSec() are application/BSP functions that MAY be
S*                   optionally defined by the developer when either of the following CPU features is
S*                   enabled :
S*
S*                   (a) CPU timestamps
S*                   (b) CPU interrupts disabled time measurements
S*
S*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
S*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
S*
S*               (2) (a) The amount of time measured by CPU timestamps is calculated by either of
S*                       the following equations :
S*
S*                                                                        10^6 microseconds
S*                       (1) Time measured  =   Number timer counts   *  -------------------  *  Timer period
S*                                                                            1 second
S*
S*                                              Number timer counts       10^6 microseconds
S*                       (2) Time measured  =  ---------------------  *  -------------------
S*                                                Timer frequency             1 second
S*
S*                               where
S*
S*                                   (A) Number timer counts     Number of timer counts measured
S*                                   (B) Timer frequency         Timer's frequency in some units
S*                                                                   of counts per second
S*                                   (C) Timer period            Timer's period in some units of
S*                                                                   (fractional)  seconds
S*                                   (D) Time measured           Amount of time measured,
S*                                                                   in microseconds
S*
S*                   (b) Timer period SHOULD be less than the typical measured time but MUST be less
S*                       than the maximum measured time; otherwise, timer resolution inadequate to
S*                       measure desired times.
S*
S*                   (c) Specific implementations may convert any number of CPU_TS32 or CPU_TS64 bits
S*                       -- up to 32 or 64, respectively -- into microseconds.
S*********************************************************************************************************
S*/
S
S#if (CPU_CFG_TS_32_EN == DEF_ENABLED)
SCPU_INT64U  CPU_TS32_to_uSec(CPU_TS32  ts_cnts);
S#endif
S
S#if (CPU_CFG_TS_64_EN == DEF_ENABLED)
SCPU_INT64U  CPU_TS64_to_uSec(CPU_TS64  ts_cnts);
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                        CONFIGURATION ERRORS
S*********************************************************************************************************
S*/
S
S#ifndef  CPU_CFG_NAME_EN
S#error  "CPU_CFG_NAME_EN                       not #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_ENABLED ]           "
S#error  "                                [     ||  DEF_DISABLED]           "
S
S#elif  ((CPU_CFG_NAME_EN != DEF_ENABLED ) && \
S        (CPU_CFG_NAME_EN != DEF_DISABLED))
X#elif  ((CPU_CFG_NAME_EN != DEF_ENABLED ) &&         (CPU_CFG_NAME_EN != DEF_DISABLED))
S#error  "CPU_CFG_NAME_EN                 illegally #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_ENABLED ]           "
S#error  "                                [     ||  DEF_DISABLED]           "
S
S
S#elif   (CPU_CFG_NAME_EN == DEF_ENABLED)
S
S#ifndef  CPU_CFG_NAME_SIZE
S#error  "CPU_CFG_NAME_SIZE                     not #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  >=   1]                 "
S#error  "                                [     &&  <= 255]                 "
S
S#elif   (DEF_CHK_VAL(CPU_CFG_NAME_SIZE,            \
S                     1,                            \
S                     DEF_INT_08U_MAX_VAL) != DEF_OK)
X#elif   (DEF_CHK_VAL(CPU_CFG_NAME_SIZE,                                 1,                                                 DEF_INT_08U_MAX_VAL) != DEF_OK)
S#error  "CPU_CFG_NAME_SIZE               illegally #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  >=   1]                 "
S#error  "                                [     &&  <= 255]                 "
S#endif
S
S#endif
S
S
S
S
S#ifndef  CPU_CFG_TS_32_EN
S#error  "CPU_CFG_TS_32_EN                      not #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
S#elif  ((CPU_CFG_TS_32_EN != DEF_DISABLED) && \
S        (CPU_CFG_TS_32_EN != DEF_ENABLED ))
X#elif  ((CPU_CFG_TS_32_EN != DEF_DISABLED) &&         (CPU_CFG_TS_32_EN != DEF_ENABLED ))
S#error  "CPU_CFG_TS_32_EN                illegally #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
S#endif
S
S
S#ifndef  CPU_CFG_TS_64_EN
S#error  "CPU_CFG_TS_64_EN                      not #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
S#elif  ((CPU_CFG_TS_64_EN != DEF_DISABLED) && \
S        (CPU_CFG_TS_64_EN != DEF_ENABLED ))
X#elif  ((CPU_CFG_TS_64_EN != DEF_DISABLED) &&         (CPU_CFG_TS_64_EN != DEF_ENABLED ))
S#error  "CPU_CFG_TS_64_EN                illegally #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
S#endif
S
S                                                                /* Correctly configured in 'cpu_core.h'; DO NOT MODIFY. */
S#ifndef  CPU_CFG_TS_EN
S#error  "CPU_CFG_TS_EN                         not #define'd in 'cpu_core.h'"
S#error  "                                [MUST be  DEF_DISABLED]            "
S#error  "                                [     ||  DEF_ENABLED ]            "
S
S#elif  ((CPU_CFG_TS_EN != DEF_DISABLED) && \
S        (CPU_CFG_TS_EN != DEF_ENABLED ))
X#elif  ((CPU_CFG_TS_EN != DEF_DISABLED) &&         (CPU_CFG_TS_EN != DEF_ENABLED ))
S#error  "CPU_CFG_TS_EN                   illegally #define'd in 'cpu_core.h'"
S#error  "                                [MUST be  DEF_DISABLED]            "
S#error  "                                [     ||  DEF_ENABLED ]            "
S
S#endif
S
S
S/*$PAGE*/
S                                                                /* Correctly configured in 'cpu_core.h'; DO NOT MODIFY. */
S#ifndef  CPU_CFG_TS_TMR_EN
S#error  "CPU_CFG_TS_TMR_EN                     not #define'd in 'cpu_core.h'"
S#error  "                                [MUST be  DEF_DISABLED]            "
S#error  "                                [     ||  DEF_ENABLED ]            "
S
S#elif  ((CPU_CFG_TS_TMR_EN != DEF_DISABLED) && \
S        (CPU_CFG_TS_TMR_EN != DEF_ENABLED ))
X#elif  ((CPU_CFG_TS_TMR_EN != DEF_DISABLED) &&         (CPU_CFG_TS_TMR_EN != DEF_ENABLED ))
S#error  "CPU_CFG_TS_TMR_EN               illegally #define'd in 'cpu_core.h'"
S#error  "                                [MUST be  DEF_DISABLED]            "
S#error  "                                [     ||  DEF_ENABLED ]            "
S
S
S#elif   (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
S
S#ifndef  CPU_CFG_TS_TMR_SIZE
S#error  "CPU_CFG_TS_TMR_SIZE                   not #define'd in 'cpu_cfg.h'       "
S#error  "                                [MUST be  CPU_WORD_SIZE_08   8-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_16  16-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_32  32-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_64  64-bit timer]"
S
S#elif  ((CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_08) && \
S        (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_16) && \
S        (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_32) && \
S        (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_64))
X#elif  ((CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_08) &&         (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_16) &&         (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_32) &&         (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_64))
S#error  "CPU_CFG_TS_TMR_SIZE             illegally #define'd in 'cpu_cfg.h'       "
S#error  "                                [MUST be  CPU_WORD_SIZE_08   8-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_16  16-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_32  32-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_64  64-bit timer]"
S#endif
S
S#endif
S
S
S
S#ifndef  CPU_CFG_INT_DIS_MEAS_EN
S#if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */
S#error  "CPU_CFG_INT_DIS_MEAS_EN               not #define'd in 'cpu_cfg.h'"
S#endif
S
S#else
S
S#ifndef  CPU_CFG_INT_DIS_MEAS_OVRHD_NBR
S#error  "CPU_CFG_INT_DIS_MEAS_OVRHD_NBR        not #define'd in 'cpu_cfg.h' "
S#error  "                                [MUST be  >= CPU_TIME_MEAS_NBR_MIN]"
S#error  "                                [     ||  <= CPU_TIME_MEAS_NBR_MAX]"
S
S#elif   (DEF_CHK_VAL(CPU_CFG_INT_DIS_MEAS_OVRHD_NBR, \
S                     CPU_TIME_MEAS_NBR_MIN,          \
S                     CPU_TIME_MEAS_NBR_MAX) != DEF_OK)
X#elif   (DEF_CHK_VAL(CPU_CFG_INT_DIS_MEAS_OVRHD_NBR,                      CPU_TIME_MEAS_NBR_MIN,                               CPU_TIME_MEAS_NBR_MAX) != DEF_OK)
S#error  "CPU_CFG_INT_DIS_MEAS_OVRHD_NBR  illegally #define'd in 'cpu_cfg.h' "
S#error  "                                [MUST be  >= CPU_TIME_MEAS_NBR_MIN]"
S#error  "                                [     ||  <= CPU_TIME_MEAS_NBR_MAX]"
S
S#endif
S
S#endif
S
S
S
S
S#ifndef  CPU_CFG_LEAD_ZEROS_ASM_PRESENT
S#if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */
S#error  "CPU_CFG_LEAD_ZEROS_ASM_PRESENT        not #define'd in 'cpu.h'/'cpu_cfg.h'"
S#endif
S#endif
S
S
S#ifndef  CPU_CFG_TRAIL_ZEROS_ASM_PRESENT
S#if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */
S#error  "CPU_CFG_TRAIL_ZEROS_ASM_PRESENT       not #define'd in 'cpu.h'/'cpu_cfg.h'"
S#endif
S#endif
S
S
S/*$PAGE*/
S/*
S*********************************************************************************************************
S*                                    CPU PORT CONFIGURATION ERRORS
S*********************************************************************************************************
S*/
S
S#ifndef  CPU_CFG_ADDR_SIZE
S#error  "CPU_CFG_ADDR_SIZE      not #define'd in 'cpu.h'"
S#endif
S
S#ifndef  CPU_CFG_DATA_SIZE
S#error  "CPU_CFG_DATA_SIZE      not #define'd in 'cpu.h'"
S#endif
S
S#ifndef  CPU_CFG_DATA_SIZE_MAX
S#error  "CPU_CFG_DATA_SIZE_MAX  not #define'd in 'cpu.h'"
S#endif
S
S
S/*
S*********************************************************************************************************
S*                                    LIBRARY CONFIGURATION ERRORS
S*********************************************************************************************************
S*/
S
S                                                                /* See 'cpu_core.h  Note #1a'.                          */
S#if     (LIB_VERSION < 13500u)
S#error  "LIB_VERSION  [SHOULD be >= V1.35.00]"
S#endif
S
S
S/*
S*********************************************************************************************************
S*                                             MODULE END
S*
S* Note(s) : (1) See 'cpu_core.h  MODULE'.
S*********************************************************************************************************
S*/
S
N#endif                                                          /* End of CPU core module include.                      */
N
L 108 "..\..\uCOS-III\uC-LIB\lib_mem.h" 2
N
N#include  <lib_def.h>
N#include  <lib_cfg.h>
L 1 "..\..\User\lib_cfg.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/LIB
N*                                        CUSTOM LIBRARY MODULES
N*
N*                          (c) Copyright 2004-2013; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/LIB is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                  CUSTOM LIBRARY CONFIGURATION FILE
N*
N*                                     ST Microelectronics STM32
N*                                              on the
N*
N*                                           STM3240G-EVAL
N*                                         Evaluation Board
N*
N* Filename      : lib_cfg.h
N* Version       : V1.35.00
N* Programmer(s) : DC
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*********************************************************************************************************
N*/
N
N#ifndef  LIB_CFG_MODULE_PRESENT
N#define  LIB_CFG_MODULE_PRESENT
N
N
N/*
N*********************************************************************************************************
N*                                          uC/LIB CONFIGURATION
N*********************************************************************************************************
N*/
N
N#define  LIB_MEM_CFG_ARG_CHK_EXT_EN     DEF_ENABLED
N                                                        /*   DEF_DISABLED     Argument check DISABLED                   */
N                                                        /*   DEF_ENABLED      Argument check ENABLED                    */
N
N#define  LIB_MEM_CFG_OPTIMIZE_ASM_EN    DEF_ENABLED
N                                                        /*   DEF_DISABLED     Assembly-optimized function(s) DISABLED   */
N                                                        /*   DEF_ENABLED      Assembly-optimized function(s) ENABLED    */
N
N#define  LIB_MEM_CFG_ALLOC_EN           DEF_ENABLED
N                                                        /*   DEF_DISABLED     Memory allocation DISABLED                */
N                                                        /*   DEF_ENABLED      Memory allocation ENABLED                 */
N
N
N#define  LIB_MEM_CFG_HEAP_SIZE          23u * 1024u     /* Configure Heap Memory Size                                   */
N
N
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*********************************************************************************************************
N*/
N
N#endif                                                  /* End of lib cfg module include.                               */
N
L 111 "..\..\uCOS-III\uC-LIB\lib_mem.h" 2
N
N
N/*
N*********************************************************************************************************
N*                                               EXTERNS
N*********************************************************************************************************
N*/
N
N#ifdef   LIB_MEM_MODULE
S#define  LIB_MEM_EXT
N#else
N#define  LIB_MEM_EXT  extern
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        DEFAULT CONFIGURATION
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                             MEMORY LIBRARY ARGUMENT CHECK CONFIGURATION
N*
N* Note(s) : (1) Configure LIB_MEM_CFG_ARG_CHK_EXT_EN to enable/disable the memory library suite external
N*               argument check feature :
N*
N*               (a) When ENABLED,      arguments received from any port interface provided by the developer
N*                   or application are checked/validated.
N*
N*               (b) When DISABLED, NO  arguments received from any port interface provided by the developer
N*                   or application are checked/validated.
N*********************************************************************************************************
N*/
N
N                                                        /* Configure external argument check feature (see Note #1) :    */
N#ifndef  LIB_MEM_CFG_ARG_CHK_EXT_EN
S#define  LIB_MEM_CFG_ARG_CHK_EXT_EN     DEF_DISABLED
S                                                        /*   DEF_DISABLED     Argument check DISABLED                   */
S                                                        /*   DEF_ENABLED      Argument check ENABLED                    */
N#endif
N
N
N/*
N*********************************************************************************************************
N*                         MEMORY LIBRARY ASSEMBLY OPTIMIZATION CONFIGURATION
N*
N* Note(s) : (1) Configure LIB_MEM_CFG_OPTIMIZE_ASM_EN to enable/disable assembly-optimized memory functions.
N*********************************************************************************************************
N*/
N
N                                                        /* Configure assembly-optimized function(s) [see Note #1] :     */
N#ifndef  LIB_MEM_CFG_OPTIMIZE_ASM_EN
S#define  LIB_MEM_CFG_OPTIMIZE_ASM_EN    DEF_DISABLED
S                                                        /*   DEF_DISABLED     Assembly-optimized function(s) DISABLED   */
S                                                        /*   DEF_ENABLED      Assembly-optimized function(s) ENABLED    */
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                   MEMORY ALLOCATION CONFIGURATION
N*
N* Note(s) : (1) Configure LIB_MEM_CFG_ALLOC_EN to enable/disable memory allocation functions.
N*********************************************************************************************************
N*/
N
N                                                        /* Configure memory allocation feature (see Note #1) :          */
N#ifndef  LIB_MEM_CFG_ALLOC_EN
S#define  LIB_MEM_CFG_ALLOC_EN           DEF_DISABLED
S                                                        /*   DEF_DISABLED     Memory allocation DISABLED                */
S                                                        /*   DEF_ENABLED      Memory allocation ENABLED                 */
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                               DEFINES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                     MEMORY LIBRARY TYPE DEFINES
N*
N* Note(s) : (1) LIB_MEM_TYPE_&&& #define values specifically chosen as ASCII representations of the memory
N*               library types.  Memory displays of memory library objects will display the library TYPEs
N*               with their chosen ASCII names.
N*********************************************************************************************************
N*/
N
N#define  LIB_MEM_TYPE_NONE                        CPU_TYPE_CREATE('N', 'O', 'N', 'E')
N#define  LIB_MEM_TYPE_HEAP                        CPU_TYPE_CREATE('H', 'E', 'A', 'P')
N#define  LIB_MEM_TYPE_POOL                        CPU_TYPE_CREATE('P', 'O', 'O', 'L')
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             DATA TYPES
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                            LIB MEM TYPE
N*
N* Note(s) : (1) 'LIB_MEM_TYPE' declared as 'CPU_INT32U' & all 'LIB_MEM_TYPE's #define'd with large, non-trivial
N*               values to trap & discard invalid/corrupted library memory objects based on 'LIB_MEM_TYPE'.
N*********************************************************************************************************
N*/
N
Ntypedef  CPU_INT32U  LIB_MEM_TYPE;
N
N
N/*
N*********************************************************************************************************
N*                                MEMORY POOL BLOCK QUANTITY DATA TYPE
N*********************************************************************************************************
N*/
N
Ntypedef  CPU_SIZE_T  MEM_POOL_BLK_QTY;
N
N
N/*
N*********************************************************************************************************
N*                                      MEMORY POOL TABLE IX TYPE
N*********************************************************************************************************
N*/
N
Ntypedef  MEM_POOL_BLK_QTY  MEM_POOL_IX;
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        MEMORY POOL DATA TYPES
N*
N*                                                                      MEMORY SEGMENT
N*                                                                     ----------------
N*                                            MEMORY POOL'S            |              | <----
N*                                             POINTERS TO             |    MEMORY    |     |
N*                    MEM_POOL                MEMORY BLOCKS            |    BLOCKS    |     |
N*               |----------------|            |---------|             |   --------   |     |
N*               |        O------------------> |    O--------------------> |      |   |     |
N*               |----------------|            |---------|             |   |      |   |     |
N*               | Pool Addr Ptrs |            |    O-------------     |   --------   |     |
N*               | Pool Size      |            |---------|       |     |              |     |
N*               |----------------|            |         |       |     |   --------   |     |
N*               |    Blk Size    |            |         |       --------> |      |   |     |
N*               |    Blk Nbr     |            |         |             |   |      |   |     |
N*               |    Blk Ix      |            |    .    |             |   --------   |     |
N*               |----------------|            |    .    |             |              |     |
N*               |----------------|            |    .    |             |      .       |     |
N*               |        O-----------------   |         |             |      .       |     |
N*               |----------------|        |   |         |             |      .       |     |
N*               |        O------------    |   |         |             |              |     |
N*               |----------------|   |    |   |---------|             |   --------   |     |
N*               |  Seg Size Tot  |   |    |   |    O--------------------> |      |   |     |
N*               |  Seg Size Rem  |   |    |   |---------|             |   |      |   |     |
N*               |----------------|   |    |   |         |             |   --------   |     |
N*               | Seg List Ptrs  |   |    |   |---------|             |              |     |
N*               |----------------|   |    |                           | ------------ |     |
N*                                    |    |                           |              | <--------
N*                                    |    |                           |              |     |   |
N*                                    |    |                           |              |     |   |
N*                                    |    |                           |              |     |   |
N*                                    |    |                           |              |     |   |
N*                                    |    |                           |              |     |   |
N*                                    |    |                           ----------------     |   |
N*                                    |    |                                                |   |
N*                                    |    --------------------------------------------------   |
N*                                    |                                                         |
N*                                    -----------------------------------------------------------
N*
N*********************************************************************************************************
N*/
N
Ntypedef  struct  mem_pool  MEM_POOL;
N
N                                                                /* --------------------- MEM POOL --------------------- */
Nstruct  mem_pool {
N    LIB_MEM_TYPE        Type;                                   /* Pool type : LIB_TYPE_POOL or LIB_TYPE_HEAP.          */
N
N    MEM_POOL           *SegHeadPtr;                             /* Ptr to head mem seg.                                 */
N    MEM_POOL           *SegPrevPtr;                             /* Ptr to PREV mem seg.                                 */
N    MEM_POOL           *SegNextPtr;                             /* Ptr to NEXT mem seg.                                 */
N    MEM_POOL           *PoolPrevPtr;                            /* Ptr to PREV mem pool.                                */
N    MEM_POOL           *PoolNextPtr;                            /* Ptr to NEXT mem pool.                                */
N
N    void               *PoolAddrStart;                          /* Ptr   to start of mem seg for mem pool blks.         */
N    void               *PoolAddrEnd;                            /* Ptr   to end   of mem seg for mem pool blks.         */
N    void              **PoolPtrs;                               /* Ptr   to mem pool's array of blk ptrs.               */
N    MEM_POOL_IX         BlkIx;                                  /* Ix  into mem pool's array of blk ptrs.               */
N    CPU_SIZE_T          PoolSize;                               /* Size  of mem pool        (in octets).                */
N    MEM_POOL_BLK_QTY    BlkNbr;                                 /* Nbr   of mem pool   blks.                            */
N    CPU_SIZE_T          BlkSize;                                /* Size  of mem pool   blks (in octets).                */
N    CPU_SIZE_T          BlkAlign;                               /* Align of mem pool   blks (in octets).                */
N
N                                                                /* --------------------- MEM SEG ---------------------- */
N    void               *SegAddr;                                /* Ptr      to mem seg's base/start addr.               */
N    void               *SegAddrNextAvail;                       /* Ptr      to mem seg's next avail addr.               */
N    CPU_SIZE_T          SegSizeTot;                             /* Tot size of mem seg (in octets).                     */
N    CPU_SIZE_T          SegSizeRem;                             /* Rem size of mem seg (in octets).                     */
N};
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          GLOBAL VARIABLES
N*********************************************************************************************************
N*/
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                              MACRO'S
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                      MEMORY DATA VALUE MACRO'S
N*
N* Note(s) : (1) (a) Some variables & variable buffers to pass & receive data values MUST start on appropriate
N*                   CPU word-aligned addresses.  This is required because most word-aligned processors are more
N*                   efficient & may even REQUIRE that multi-octet words start on CPU word-aligned addresses.
N*
N*                   (1) For 16-bit word-aligned processors, this means that
N*
N*                           all 16- & 32-bit words MUST start on addresses that are multiples of 2 octets
N*
N*                   (2) For 32-bit word-aligned processors, this means that
N*
N*                           all 16-bit       words MUST start on addresses that are multiples of 2 octets
N*                           all 32-bit       words MUST start on addresses that are multiples of 4 octets
N*
N*               (b) However, some data values macro's appropriately access data values from any CPU addresses,
N*                   word-aligned or not.  Thus for processors that require data word alignment, data words can
N*                   be accessed to/from any CPU address, word-aligned or not, without generating data-word-
N*                   alignment exceptions/faults.
N*********************************************************************************************************
N*/
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                      ENDIAN WORD ORDER MACRO'S
N*
N* Description : Convert data values to & from big-, little, or host-endian CPU word order.
N*
N* Argument(s) : val       Data value to convert (see Notes #1 & #2).
N*
N* Return(s)   : Converted data value (see Notes #1 & #2).
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) Convert data values to the desired data-word order :
N*
N*                       MEM_VAL_BIG_TO_LITTLE_xx()      Convert big-        endian data values
N*                                                            to little-     endian data values
N*                       MEM_VAL_LITTLE_TO_BIG_xx()      Convert little-     endian data values
N*                                                            to big-        endian data values
N*                       MEM_VAL_xxx_TO_HOST_xx()        Convert big-/little-endian data values
N*                                                            to host-       endian data values
N*                       MEM_VAL_HOST_TO_xxx_xx()        Convert host-       endian data values
N*                                                            to big-/little-endian data values
N*
N*                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
N*
N*               (2) 'val' data value to convert & any variable to receive the returned conversion MUST
N*                   start on appropriate CPU word-aligned addresses.
N*
N*                   See also 'MEMORY DATA VALUE MACRO'S  Note #1a'.
N*
N*               (3) MEM_VAL_COPY_xxx() macro's are more efficient than generic endian word order macro's &
N*                   are also independent of CPU data-word-alignment & SHOULD be used whenever possible.
N*
N*                   See also 'MEM_VAL_COPY_GET_xxx()  Note #4'
N*                          & 'MEM_VAL_COPY_SET_xxx()  Note #4'.
N*
N*               (4) Generic endian word order macro's are NOT atomic operations & MUST NOT be used on any
N*                   non-static (i.e. volatile) variables, registers, hardware, etc.; without the caller of
N*                   the macro's providing some form of additional protection (e.g. mutual exclusion).
N*
N*               (5) The 'CPU_CFG_ENDIAN_TYPE' pre-processor 'else'-conditional code SHOULD never be compiled/
N*                   linked since each 'cpu.h' SHOULD ensure that the CPU data-word-memory order configuration
N*                   constant (CPU_CFG_ENDIAN_TYPE) is configured with an appropriate data-word-memory order
N*                   value (see 'cpu.h  CPU WORD CONFIGURATION  Note #2').  The 'else'-conditional code is
N*                   included as an extra precaution in case 'cpu.h' is incorrectly configured.
N*********************************************************************************************************
N*/
N/*$PAGE*/
N
N#if    ((CPU_CFG_DATA_SIZE == CPU_WORD_SIZE_64) || \
N        (CPU_CFG_DATA_SIZE == CPU_WORD_SIZE_32))
X#if    ((4 == 8) ||         (4 == 4))
N
N#define  MEM_VAL_BIG_TO_LITTLE_16(val)        ((CPU_INT16U)(((CPU_INT16U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0xFF00u) >> (1u * DEF_OCTET_NBR_BITS))) | \
N                                                            ((CPU_INT16U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0x00FFu) << (1u * DEF_OCTET_NBR_BITS)))))
X#define  MEM_VAL_BIG_TO_LITTLE_16(val)        ((CPU_INT16U)(((CPU_INT16U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0xFF00u) >> (1u * DEF_OCTET_NBR_BITS))) |                                                             ((CPU_INT16U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0x00FFu) << (1u * DEF_OCTET_NBR_BITS)))))
N
N#define  MEM_VAL_BIG_TO_LITTLE_32(val)        ((CPU_INT32U)(((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0xFF000000u) >> (3u * DEF_OCTET_NBR_BITS))) | \
N                                                            ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x00FF0000u) >> (1u * DEF_OCTET_NBR_BITS))) | \
N                                                            ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x0000FF00u) << (1u * DEF_OCTET_NBR_BITS))) | \
N                                                            ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x000000FFu) << (3u * DEF_OCTET_NBR_BITS)))))
X#define  MEM_VAL_BIG_TO_LITTLE_32(val)        ((CPU_INT32U)(((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0xFF000000u) >> (3u * DEF_OCTET_NBR_BITS))) |                                                             ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x00FF0000u) >> (1u * DEF_OCTET_NBR_BITS))) |                                                             ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x0000FF00u) << (1u * DEF_OCTET_NBR_BITS))) |                                                             ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x000000FFu) << (3u * DEF_OCTET_NBR_BITS)))))
N
N#elif   (CPU_CFG_DATA_SIZE == CPU_WORD_SIZE_16)
S
S#define  MEM_VAL_BIG_TO_LITTLE_16(val)        ((CPU_INT16U)(((CPU_INT16U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0xFF00u) >> (1u * DEF_OCTET_NBR_BITS))) | \
S                                                            ((CPU_INT16U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0x00FFu) << (1u * DEF_OCTET_NBR_BITS)))))
X#define  MEM_VAL_BIG_TO_LITTLE_16(val)        ((CPU_INT16U)(((CPU_INT16U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0xFF00u) >> (1u * DEF_OCTET_NBR_BITS))) |                                                             ((CPU_INT16U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0x00FFu) << (1u * DEF_OCTET_NBR_BITS)))))
S
S#define  MEM_VAL_BIG_TO_LITTLE_32(val)        ((CPU_INT32U)(((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0xFF000000u) >> (1u * DEF_OCTET_NBR_BITS))) | \
S                                                            ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x00FF0000u) << (1u * DEF_OCTET_NBR_BITS))) | \
S                                                            ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x0000FF00u) >> (1u * DEF_OCTET_NBR_BITS))) | \
S                                                            ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x000000FFu) << (1u * DEF_OCTET_NBR_BITS)))))
X#define  MEM_VAL_BIG_TO_LITTLE_32(val)        ((CPU_INT32U)(((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0xFF000000u) >> (1u * DEF_OCTET_NBR_BITS))) |                                                             ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x00FF0000u) << (1u * DEF_OCTET_NBR_BITS))) |                                                             ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x0000FF00u) >> (1u * DEF_OCTET_NBR_BITS))) |                                                             ((CPU_INT32U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x000000FFu) << (1u * DEF_OCTET_NBR_BITS)))))
S
S#else
S
S#define  MEM_VAL_BIG_TO_LITTLE_16(val)                                                  (val)
S#define  MEM_VAL_BIG_TO_LITTLE_32(val)                                                  (val)
S
N#endif
N
N
N#define  MEM_VAL_LITTLE_TO_BIG_16(val)                          MEM_VAL_BIG_TO_LITTLE_16(val)
N#define  MEM_VAL_LITTLE_TO_BIG_32(val)                          MEM_VAL_BIG_TO_LITTLE_32(val)
N
N
N
N#if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
X#if     (2u == 1u)
S
S#define  MEM_VAL_BIG_TO_HOST_16(val)                                                    (val)
S#define  MEM_VAL_BIG_TO_HOST_32(val)                                                    (val)
S#define  MEM_VAL_LITTLE_TO_HOST_16(val)                         MEM_VAL_LITTLE_TO_BIG_16(val)
S#define  MEM_VAL_LITTLE_TO_HOST_32(val)                         MEM_VAL_LITTLE_TO_BIG_32(val)
S
N#elif   (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_LITTLE)
X#elif   (2u == 2u)
N
N#define  MEM_VAL_BIG_TO_HOST_16(val)                            MEM_VAL_BIG_TO_LITTLE_16(val)
N#define  MEM_VAL_BIG_TO_HOST_32(val)                            MEM_VAL_BIG_TO_LITTLE_32(val)
N#define  MEM_VAL_LITTLE_TO_HOST_16(val)                                                 (val)
N#define  MEM_VAL_LITTLE_TO_HOST_32(val)                                                 (val)
N
N#else                                                               /* See Note #5.                                     */
S
S#error  "CPU_CFG_ENDIAN_TYPE  illegally #defined in 'cpu.h'      "
S#error  "                     [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N#define  MEM_VAL_HOST_TO_BIG_16(val)                            MEM_VAL_BIG_TO_HOST_16(val)
N#define  MEM_VAL_HOST_TO_BIG_32(val)                            MEM_VAL_BIG_TO_HOST_32(val)
N#define  MEM_VAL_HOST_TO_LITTLE_16(val)                         MEM_VAL_LITTLE_TO_HOST_16(val)
N#define  MEM_VAL_HOST_TO_LITTLE_32(val)                         MEM_VAL_LITTLE_TO_HOST_32(val)
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          MEM_VAL_GET_xxx()
N*
N* Description : Decode data values from any CPU memory address.
N*
N* Argument(s) : addr        Lowest CPU memory address of data value to decode (see Notes #2 & #3a).
N*
N* Return(s)   : Decoded data value from CPU memory address (see Notes #1 & #3b).
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) Decode data values based on the values' data-word order in CPU memory :
N*
N*                       MEM_VAL_GET_xxx_BIG()           Decode big-   endian data values -- data words' most
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_GET_xxx_LITTLE()        Decode little-endian data values -- data words' least
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_GET_xxx()               Decode data values using CPU's native or configured
N*                                                           data-word order
N*
N*                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
N*
N*               (2) CPU memory addresses/pointers NOT checked for NULL.
N*
N*               (3) (a) MEM_VAL_GET_xxx() macro's decode data values without regard to CPU word-aligned addresses.
N*                       Thus for processors that require data word alignment, data words can be decoded from any
N*                       CPU address, word-aligned or not, without generating data-word-alignment exceptions/faults.
N*
N*                   (b) However, any variable to receive the returned data value MUST start on an appropriate CPU
N*                       word-aligned address.
N*
N*                   See also 'MEMORY DATA VALUE MACRO'S  Note #1'.
N*
N*               (4) MEM_VAL_COPY_GET_xxx() macro's are more efficient than MEM_VAL_GET_xxx() macro's & are
N*                   also independent of CPU data-word-alignment & SHOULD be used whenever possible.
N*
N*                   See also 'MEM_VAL_COPY_GET_xxx()  Note #4'.
N*
N*               (5) MEM_VAL_GET_xxx() macro's are NOT atomic operations & MUST NOT be used on any non-static
N*                   (i.e. volatile) variables, registers, hardware, etc.; without the caller of the macro's
N*                   providing some form of additional protection (e.g. mutual exclusion).
N*
N*               (6) The 'CPU_CFG_ENDIAN_TYPE' pre-processor 'else'-conditional code SHOULD never be compiled/
N*                   linked since each 'cpu.h' SHOULD ensure that the CPU data-word-memory order configuration
N*                   constant (CPU_CFG_ENDIAN_TYPE) is configured with an appropriate data-word-memory order
N*                   value (see 'cpu.h  CPU WORD CONFIGURATION  Note #2').  The 'else'-conditional code is
N*                   included as an extra precaution in case 'cpu.h' is incorrectly configured.
N*********************************************************************************************************
N*/
N/*$PAGE*/
N
N#define  MEM_VAL_GET_INT08U_BIG(addr)           ((CPU_INT08U) ((CPU_INT08U)(((CPU_INT08U)(*(((CPU_INT08U *)(addr)) + 0))) << (0u * DEF_OCTET_NBR_BITS))))
N
N#define  MEM_VAL_GET_INT16U_BIG(addr)           ((CPU_INT16U)(((CPU_INT16U)(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 0))) << (1u * DEF_OCTET_NBR_BITS))) + \
N                                                              ((CPU_INT16U)(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 1))) << (0u * DEF_OCTET_NBR_BITS)))))
X#define  MEM_VAL_GET_INT16U_BIG(addr)           ((CPU_INT16U)(((CPU_INT16U)(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 0))) << (1u * DEF_OCTET_NBR_BITS))) +                                                               ((CPU_INT16U)(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 1))) << (0u * DEF_OCTET_NBR_BITS)))))
N
N#define  MEM_VAL_GET_INT32U_BIG(addr)           ((CPU_INT32U)(((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 0))) << (3u * DEF_OCTET_NBR_BITS))) + \
N                                                              ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 1))) << (2u * DEF_OCTET_NBR_BITS))) + \
N                                                              ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 2))) << (1u * DEF_OCTET_NBR_BITS))) + \
N                                                              ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 3))) << (0u * DEF_OCTET_NBR_BITS)))))
X#define  MEM_VAL_GET_INT32U_BIG(addr)           ((CPU_INT32U)(((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 0))) << (3u * DEF_OCTET_NBR_BITS))) +                                                               ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 1))) << (2u * DEF_OCTET_NBR_BITS))) +                                                               ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 2))) << (1u * DEF_OCTET_NBR_BITS))) +                                                               ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 3))) << (0u * DEF_OCTET_NBR_BITS)))))
N
N
N
N#define  MEM_VAL_GET_INT08U_LITTLE(addr)        ((CPU_INT08U) ((CPU_INT08U)(((CPU_INT08U)(*(((CPU_INT08U *)(addr)) + 0))) << (0u * DEF_OCTET_NBR_BITS))))
N
N#define  MEM_VAL_GET_INT16U_LITTLE(addr)        ((CPU_INT16U)(((CPU_INT16U)(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 0))) << (0u * DEF_OCTET_NBR_BITS))) + \
N                                                              ((CPU_INT16U)(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 1))) << (1u * DEF_OCTET_NBR_BITS)))))
X#define  MEM_VAL_GET_INT16U_LITTLE(addr)        ((CPU_INT16U)(((CPU_INT16U)(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 0))) << (0u * DEF_OCTET_NBR_BITS))) +                                                               ((CPU_INT16U)(((CPU_INT16U)(*(((CPU_INT08U *)(addr)) + 1))) << (1u * DEF_OCTET_NBR_BITS)))))
N
N#define  MEM_VAL_GET_INT32U_LITTLE(addr)        ((CPU_INT32U)(((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 0))) << (0u * DEF_OCTET_NBR_BITS))) + \
N                                                              ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 1))) << (1u * DEF_OCTET_NBR_BITS))) + \
N                                                              ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 2))) << (2u * DEF_OCTET_NBR_BITS))) + \
N                                                              ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 3))) << (3u * DEF_OCTET_NBR_BITS)))))
X#define  MEM_VAL_GET_INT32U_LITTLE(addr)        ((CPU_INT32U)(((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 0))) << (0u * DEF_OCTET_NBR_BITS))) +                                                               ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 1))) << (1u * DEF_OCTET_NBR_BITS))) +                                                               ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 2))) << (2u * DEF_OCTET_NBR_BITS))) +                                                               ((CPU_INT32U)(((CPU_INT32U)(*(((CPU_INT08U *)(addr)) + 3))) << (3u * DEF_OCTET_NBR_BITS)))))
N
N
N
N#if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
X#if     (2u == 1u)
S
S#define  MEM_VAL_GET_INT08U(addr)                               MEM_VAL_GET_INT08U_BIG(addr)
S#define  MEM_VAL_GET_INT16U(addr)                               MEM_VAL_GET_INT16U_BIG(addr)
S#define  MEM_VAL_GET_INT32U(addr)                               MEM_VAL_GET_INT32U_BIG(addr)
S
N#elif   (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_LITTLE)
X#elif   (2u == 2u)
N
N#define  MEM_VAL_GET_INT08U(addr)                               MEM_VAL_GET_INT08U_LITTLE(addr)
N#define  MEM_VAL_GET_INT16U(addr)                               MEM_VAL_GET_INT16U_LITTLE(addr)
N#define  MEM_VAL_GET_INT32U(addr)                               MEM_VAL_GET_INT32U_LITTLE(addr)
N
N#else                                                               /* See Note #6.                                     */
S
S#error  "CPU_CFG_ENDIAN_TYPE  illegally #defined in 'cpu.h'      "
S#error  "                     [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          MEM_VAL_SET_xxx()
N*
N* Description : Encode data values to any CPU memory address.
N*
N* Argument(s) : addr        Lowest CPU memory address to encode data value (see Notes #2 & #3a).
N*
N*               val         Data value to encode (see Notes #1 & #3b).
N*
N* Return(s)   : none.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) Encode data values into CPU memory based on the values' data-word order :
N*
N*                       MEM_VAL_SET_xxx_BIG()           Encode big-   endian data values -- data words' most
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_SET_xxx_LITTLE()        Encode little-endian data values -- data words' least
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_SET_xxx()               Encode data values using CPU's native or configured
N*                                                           data-word order
N*
N*                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
N*
N*               (2) CPU memory addresses/pointers NOT checked for NULL.
N*
N*               (3) (a) MEM_VAL_SET_xxx() macro's encode data values without regard to CPU word-aligned addresses.
N*                       Thus for processors that require data word alignment, data words can be encoded to any
N*                       CPU address, word-aligned or not, without generating data-word-alignment exceptions/faults.
N*
N*                   (b) However, 'val' data value to encode MUST start on an appropriate CPU word-aligned address.
N*
N*                   See also 'MEMORY DATA VALUE MACRO'S  Note #1'.
N*
N*               (4) MEM_VAL_COPY_SET_xxx() macro's are more efficient than MEM_VAL_SET_xxx() macro's & are
N*                   also independent of CPU data-word-alignment & SHOULD be used whenever possible.
N*
N*                   See also 'MEM_VAL_COPY_SET_xxx()  Note #4'.
N*
N*               (5) MEM_VAL_SET_xxx() macro's are NOT atomic operations & MUST NOT be used on any non-static
N*                   (i.e. volatile) variables, registers, hardware, etc.; without the caller of the macro's
N*                   providing some form of additional protection (e.g. mutual exclusion).
N*
N*               (6) The 'CPU_CFG_ENDIAN_TYPE' pre-processor 'else'-conditional code SHOULD never be compiled/
N*                   linked since each 'cpu.h' SHOULD ensure that the CPU data-word-memory order configuration
N*                   constant (CPU_CFG_ENDIAN_TYPE) is configured with an appropriate data-word-memory order
N*                   value (see 'cpu.h  CPU WORD CONFIGURATION  Note #2').  The 'else'-conditional code is
N*                   included as an extra precaution in case 'cpu.h' is incorrectly configured.
N*********************************************************************************************************
N*/
N/*$PAGE*/
N
N#define  MEM_VAL_SET_INT08U_BIG(addr, val)                     do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT08U)(val)) & (CPU_INT08U)      0xFFu) >> (0u * DEF_OCTET_NBR_BITS))); } while (0)
N
N#define  MEM_VAL_SET_INT16U_BIG(addr, val)                     do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0xFF00u) >> (1u * DEF_OCTET_NBR_BITS))); \
N                                                                    (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0x00FFu) >> (0u * DEF_OCTET_NBR_BITS))); } while (0)
X#define  MEM_VAL_SET_INT16U_BIG(addr, val)                     do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0xFF00u) >> (1u * DEF_OCTET_NBR_BITS)));                                                                     (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0x00FFu) >> (0u * DEF_OCTET_NBR_BITS))); } while (0)
N
N#define  MEM_VAL_SET_INT32U_BIG(addr, val)                     do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0xFF000000u) >> (3u * DEF_OCTET_NBR_BITS))); \
N                                                                    (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x00FF0000u) >> (2u * DEF_OCTET_NBR_BITS))); \
N                                                                    (*(((CPU_INT08U *)(addr)) + 2)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x0000FF00u) >> (1u * DEF_OCTET_NBR_BITS))); \
N                                                                    (*(((CPU_INT08U *)(addr)) + 3)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x000000FFu) >> (0u * DEF_OCTET_NBR_BITS))); } while (0)
X#define  MEM_VAL_SET_INT32U_BIG(addr, val)                     do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0xFF000000u) >> (3u * DEF_OCTET_NBR_BITS)));                                                                     (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x00FF0000u) >> (2u * DEF_OCTET_NBR_BITS)));                                                                     (*(((CPU_INT08U *)(addr)) + 2)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x0000FF00u) >> (1u * DEF_OCTET_NBR_BITS)));                                                                     (*(((CPU_INT08U *)(addr)) + 3)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x000000FFu) >> (0u * DEF_OCTET_NBR_BITS))); } while (0)
N
N
N
N#define  MEM_VAL_SET_INT08U_LITTLE(addr, val)                  do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT08U)(val)) & (CPU_INT08U)      0xFFu) >> (0u * DEF_OCTET_NBR_BITS))); } while (0)
N
N#define  MEM_VAL_SET_INT16U_LITTLE(addr, val)                  do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0x00FFu) >> (0u * DEF_OCTET_NBR_BITS))); \
N                                                                    (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0xFF00u) >> (1u * DEF_OCTET_NBR_BITS))); } while (0)
X#define  MEM_VAL_SET_INT16U_LITTLE(addr, val)                  do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0x00FFu) >> (0u * DEF_OCTET_NBR_BITS)));                                                                     (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT16U)(val)) & (CPU_INT16U)    0xFF00u) >> (1u * DEF_OCTET_NBR_BITS))); } while (0)
N
N#define  MEM_VAL_SET_INT32U_LITTLE(addr, val)                  do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x000000FFu) >> (0u * DEF_OCTET_NBR_BITS))); \
N                                                                    (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x0000FF00u) >> (1u * DEF_OCTET_NBR_BITS))); \
N                                                                    (*(((CPU_INT08U *)(addr)) + 2)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x00FF0000u) >> (2u * DEF_OCTET_NBR_BITS))); \
N                                                                    (*(((CPU_INT08U *)(addr)) + 3)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0xFF000000u) >> (3u * DEF_OCTET_NBR_BITS))); } while (0)
X#define  MEM_VAL_SET_INT32U_LITTLE(addr, val)                  do { (*(((CPU_INT08U *)(addr)) + 0)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x000000FFu) >> (0u * DEF_OCTET_NBR_BITS)));                                                                     (*(((CPU_INT08U *)(addr)) + 1)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x0000FF00u) >> (1u * DEF_OCTET_NBR_BITS)));                                                                     (*(((CPU_INT08U *)(addr)) + 2)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0x00FF0000u) >> (2u * DEF_OCTET_NBR_BITS)));                                                                     (*(((CPU_INT08U *)(addr)) + 3)) = ((CPU_INT08U)((((CPU_INT32U)(val)) & (CPU_INT32U)0xFF000000u) >> (3u * DEF_OCTET_NBR_BITS))); } while (0)
N
N
N
N#if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
X#if     (2u == 1u)
S
S#define  MEM_VAL_SET_INT08U(addr, val)                          MEM_VAL_SET_INT08U_BIG(addr, val)
S#define  MEM_VAL_SET_INT16U(addr, val)                          MEM_VAL_SET_INT16U_BIG(addr, val)
S#define  MEM_VAL_SET_INT32U(addr, val)                          MEM_VAL_SET_INT32U_BIG(addr, val)
S
N#elif   (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_LITTLE)
X#elif   (2u == 2u)
N
N#define  MEM_VAL_SET_INT08U(addr, val)                          MEM_VAL_SET_INT08U_LITTLE(addr, val)
N#define  MEM_VAL_SET_INT16U(addr, val)                          MEM_VAL_SET_INT16U_LITTLE(addr, val)
N#define  MEM_VAL_SET_INT32U(addr, val)                          MEM_VAL_SET_INT32U_LITTLE(addr, val)
N
N#else                                                               /* See Note #6.                                     */
S
S#error  "CPU_CFG_ENDIAN_TYPE  illegally #defined in 'cpu.h'      "
S#error  "                     [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                       MEM_VAL_COPY_GET_xxx()
N*
N* Description : Copy & decode data values from any CPU memory address to any CPU memory address.
N*
N* Argument(s) : addr_dest       Lowest CPU memory address to copy/decode source address's data value
N*                                   (see Notes #2 & #3).
N*
N*               addr_src        Lowest CPU memory address of data value to copy/decode
N*                                   (see Notes #2 & #3).
N*
N* Return(s)   : none.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) Copy/decode data values based on the values' data-word order :
N*
N*                       MEM_VAL_COPY_GET_xxx_BIG()      Decode big-   endian data values -- data words' most
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_COPY_GET_xxx_LITTLE()   Decode little-endian data values -- data words' least
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_COPY_GET_xxx()          Decode data values using CPU's native or configured
N*                                                           data-word order
N*
N*                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
N*
N*               (2) (a) CPU memory addresses/pointers NOT checked for NULL.
N*
N*                   (b) CPU memory addresses/buffers  NOT checked for overlapping.
N*
N*                       (1) IEEE Std 1003.1, 2004 Edition, Section 'memcpy() : DESCRIPTION' states that
N*                           "copying ... between objects that overlap ... is undefined".
N*
N*               (3) MEM_VAL_COPY_GET_xxx() macro's copy/decode data values without regard to CPU word-aligned
N*                   addresses.  Thus for processors that require data word alignment, data words can be copied/
N*                   decoded to/from any CPU address, word-aligned or not, without generating data-word-alignment
N*                   exceptions/faults.
N*
N*               (4) MEM_VAL_COPY_GET_xxx() macro's are more efficient than MEM_VAL_GET_xxx() macro's & are
N*                   also independent of CPU data-word-alignment & SHOULD be used whenever possible.
N*
N*                   See also 'MEM_VAL_GET_xxx()  Note #4'.
N*
N*               (5) Since octet-order copy/conversion are inverse operations, MEM_VAL_COPY_GET_xxx() &
N*                   MEM_VAL_COPY_SET_xxx() macros are inverse, but identical, operations & are provided
N*                   in both forms for semantics & consistency.
N*
N*                   See also 'MEM_VAL_COPY_SET_xxx()  Note #5'.
N*
N*               (6) MEM_VAL_COPY_GET_xxx() macro's are NOT atomic operations & MUST NOT be used on any non-
N*                   static (i.e. volatile) variables, registers, hardware, etc.; without the caller of the
N*                   macro's providing some form of additional protection (e.g. mutual exclusion).
N*
N*               (7) The 'CPU_CFG_ENDIAN_TYPE' pre-processor 'else'-conditional code SHOULD never be compiled/
N*                   linked since each 'cpu.h' SHOULD ensure that the CPU data-word-memory order configuration
N*                   constant (CPU_CFG_ENDIAN_TYPE) is configured with an appropriate data-word-memory order
N*                   value (see 'cpu.h  CPU WORD CONFIGURATION  Note #2').  The 'else'-conditional code is
N*                   included as an extra precaution in case 'cpu.h' is incorrectly configured.
N*********************************************************************************************************
N*/
N/*$PAGE*/
N
N#if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
X#if     (2u == 1u)
S
S
S#define  MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
S
S#define  MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
S                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); } while (0)
X#define  MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); } while (0)
S
S#define  MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
S                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
S                                                                    (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2)); \
S                                                                    (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); } while (0)
X#define  MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); } while (0)
S
S
S
S#define  MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
S
S#define  MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
S                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
X#define  MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 1));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
S
S#define  MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 3)); \
S                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 2)); \
S                                                                    (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
S                                                                    (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
X#define  MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 3));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 2));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 1));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
S
S
S
S#define  MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)
S#define  MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)
S#define  MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)
S
S
S
S
N#elif   (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_LITTLE)
X#elif   (2u == 2u)
N
N
N#define  MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
N
N#define  MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
X#define  MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 1));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
N
N#define  MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 3)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 2)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
X#define  MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)      do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 3));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 2));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 1));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
N
N
N
N#define  MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
N
N#define  MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); } while (0)
X#define  MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); } while (0)
N
N#define  MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); } while (0)
X#define  MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)   do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); } while (0)
N
N
N
N#define  MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)
N#define  MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)
N#define  MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)
N
N
N
N
N#else                                                               /* See Note #7.                                     */
S
S#error  "CPU_CFG_ENDIAN_TYPE  illegally #defined in 'cpu.h'      "
S#error  "                     [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                     MEM_VAL_COPY_GET_INTU_xxx()
N*
N* Description : Copy & decode data values from any CPU memory address to any CPU memory address for
N*                   any sized data values.
N*
N* Argument(s) : addr_dest       Lowest CPU memory address to copy/decode source address's data value
N*                                   (see Notes #2 & #3).
N*
N*               addr_src        Lowest CPU memory address of data value to copy/decode
N*                                   (see Notes #2 & #3).
N*
N*               val_size        Number of data value octets to copy/decode.
N*
N* Return(s)   : none.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) Copy/decode data values based on the values' data-word order :
N*
N*                       MEM_VAL_COPY_GET_INTU_BIG()     Decode big-   endian data values -- data words' most
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_COPY_GET_INTU_LITTLE()  Decode little-endian data values -- data words' least
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_COPY_GET_INTU()         Decode data values using CPU's native or configured
N*                                                           data-word order
N*
N*                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
N*
N*               (2) (a) CPU memory addresses/pointers NOT checked for NULL.
N*
N*                   (b) CPU memory addresses/buffers  NOT checked for overlapping.
N*
N*                       (1) IEEE Std 1003.1, 2004 Edition, Section 'memcpy() : DESCRIPTION' states that
N*                           "copying ... between objects that overlap ... is undefined".
N*
N*               (3) MEM_VAL_COPY_GET_INTU_xxx() macro's copy/decode data values without regard to CPU word-
N*                   aligned addresses.  Thus for processors that require data word alignment, data words
N*                   can be copied/decoded to/from any CPU address, word-aligned or not, without generating
N*                   data-word-alignment exceptions/faults.
N*
N*               (4) MEM_VAL_COPY_GET_xxx() macro's are more efficient than MEM_VAL_COPY_GET_INTU_xxx()
N*                   macro's & SHOULD be used whenever possible.
N*
N*                   See also 'MEM_VAL_COPY_GET_xxx()  Note #4'.
N*
N*               (5) Since octet-order copy/conversion are inverse operations, MEM_VAL_COPY_GET_INTU_xxx() &
N*                   MEM_VAL_COPY_SET_INTU_xxx() macros are inverse, but identical, operations & are provided
N*                   in both forms for semantics & consistency.
N*
N*                   See also 'MEM_VAL_COPY_SET_INTU_xxx()  Note #5'.
N*
N*               (6) MEM_VAL_COPY_GET_INTU_xxx() macro's are NOT atomic operations & MUST NOT be used on any
N*                   non-static (i.e. volatile) variables, registers, hardware, etc.; without the caller of
N*                   the macro's providing some form of additional protection (e.g. mutual exclusion).
N*
N*               (7) MISRA-C 2004 Rule 5.2 states that "identifiers in an inner scope shall not use the same
N*                   name as an indentifier in an outer scope, and therefore hide that identifier".
N*
N*                   Therefore, to avoid possible redeclaration of commonly-used loop counter identifier names,
N*                   'i' & 'j', MEM_VAL_COPY_GET_INTU_xxx() loop counter identifier names are prefixed with a
N*                   single underscore.
N*
N*               (8) The 'CPU_CFG_ENDIAN_TYPE' pre-processor 'else'-conditional code SHOULD never be compiled/
N*                   linked since each 'cpu.h' SHOULD ensure that the CPU data-word-memory order configuration
N*                   constant (CPU_CFG_ENDIAN_TYPE) is configured with an appropriate data-word-memory order
N*                   value (see 'cpu.h  CPU WORD CONFIGURATION  Note #2').  The 'else'-conditional code is
N*                   included as an extra precaution in case 'cpu.h' is incorrectly configured.
N*********************************************************************************************************
N*/
N/*$PAGE*/
N
N#if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
X#if     (2u == 1u)
S
S
S#define  MEM_VAL_COPY_GET_INTU_BIG(addr_dest, addr_src, val_size)       do {                                                                                  \
S                                                                            CPU_SIZE_T  _i;                                                                   \
S                                                                                                                                                              \
S                                                                            for (_i = 0; _i < (val_size); _i++) {                                             \
S                                                                                (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _i)); \
S                                                                            }                                                                                 \
S                                                                        } while (0)
X#define  MEM_VAL_COPY_GET_INTU_BIG(addr_dest, addr_src, val_size)       do {                                                                                                                                                              CPU_SIZE_T  _i;                                                                                                                                                                                                                                                                                                             for (_i = 0; _i < (val_size); _i++) {                                                                                                                             (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _i));                                                                             }                                                                                                                                                         } while (0)
S
S
S#define  MEM_VAL_COPY_GET_INTU_LITTLE(addr_dest, addr_src, val_size)    do {                                                                                  \
S                                                                            CPU_SIZE_T  _i;                                                                   \
S                                                                            CPU_SIZE_T  _j;                                                                   \
S                                                                                                                                                              \
S                                                                                                                                                              \
S                                                                            _j = (val_size) - 1;                                                              \
S                                                                                                                                                              \
S                                                                            for (_i = 0; _i < (val_size); _i++) {                                             \
S                                                                                (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _j)); \
S                                                                                _j--;                                                                         \
S                                                                            }                                                                                 \
S                                                                        } while (0)
X#define  MEM_VAL_COPY_GET_INTU_LITTLE(addr_dest, addr_src, val_size)    do {                                                                                                                                                              CPU_SIZE_T  _i;                                                                                                                                               CPU_SIZE_T  _j;                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _j = (val_size) - 1;                                                                                                                                                                                                                                                                                                        for (_i = 0; _i < (val_size); _i++) {                                                                                                                             (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _j));                                                                                 _j--;                                                                                                                                                     }                                                                                                                                                         } while (0)
S
S
S#define  MEM_VAL_COPY_GET_INTU(addr_dest, addr_src, val_size)           MEM_VAL_COPY_GET_INTU_BIG(addr_dest, addr_src, val_size)
S
S
S
S
N#elif   (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_LITTLE)
X#elif   (2u == 2u)
N
N
N#define  MEM_VAL_COPY_GET_INTU_BIG(addr_dest, addr_src, val_size)       do {                                                                                  \
N                                                                            CPU_SIZE_T  _i;                                                                   \
N                                                                            CPU_SIZE_T  _j;                                                                   \
N                                                                                                                                                              \
N                                                                                                                                                              \
N                                                                            _j = (val_size) - 1;                                                              \
N                                                                                                                                                              \
N                                                                            for (_i = 0; _i < (val_size); _i++) {                                             \
N                                                                                (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _j)); \
N                                                                                _j--;                                                                         \
N                                                                            }                                                                                 \
N                                                                        } while (0)
X#define  MEM_VAL_COPY_GET_INTU_BIG(addr_dest, addr_src, val_size)       do {                                                                                                                                                              CPU_SIZE_T  _i;                                                                                                                                               CPU_SIZE_T  _j;                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _j = (val_size) - 1;                                                                                                                                                                                                                                                                                                        for (_i = 0; _i < (val_size); _i++) {                                                                                                                             (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _j));                                                                                 _j--;                                                                                                                                                     }                                                                                                                                                         } while (0)
N
N
N#define  MEM_VAL_COPY_GET_INTU_LITTLE(addr_dest, addr_src, val_size)    do {                                                                                  \
N                                                                            CPU_SIZE_T  _i;                                                                   \
N                                                                                                                                                              \
N                                                                            for (_i = 0; _i < (val_size); _i++) {                                             \
N                                                                                (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _i)); \
N                                                                            }                                                                                 \
N                                                                        } while (0)
X#define  MEM_VAL_COPY_GET_INTU_LITTLE(addr_dest, addr_src, val_size)    do {                                                                                                                                                              CPU_SIZE_T  _i;                                                                                                                                                                                                                                                                                                             for (_i = 0; _i < (val_size); _i++) {                                                                                                                             (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _i));                                                                             }                                                                                                                                                         } while (0)
N
N
N#define  MEM_VAL_COPY_GET_INTU(addr_dest, addr_src, val_size)           MEM_VAL_COPY_GET_INTU_LITTLE(addr_dest, addr_src, val_size)
N
N
N
N
N#else                                                                   /* See Note #8.                                 */
S
S#error  "CPU_CFG_ENDIAN_TYPE  illegally #defined in 'cpu.h'      "
S#error  "                     [See 'cpu.h  CONFIGURATION ERRORS']"
S
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                       MEM_VAL_COPY_SET_xxx()
N*
N* Description : Copy & encode data values from any CPU memory address to any CPU memory address.
N*
N* Argument(s) : addr_dest       Lowest CPU memory address to copy/encode source address's data value
N*                                   (see Notes #2 & #3).
N*
N*               addr_src        Lowest CPU memory address of data value to copy/encode
N*                                   (see Notes #2 & #3).
N*
N* Return(s)   : none.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) Copy/encode data values based on the values' data-word order :
N*
N*                       MEM_VAL_COPY_SET_xxx_BIG()      Encode big-   endian data values -- data words' most
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_COPY_SET_xxx_LITTLE()   Encode little-endian data values -- data words' least
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_COPY_SET_xxx()          Encode data values using CPU's native or configured
N*                                                           data-word order
N*
N*                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
N*
N*               (2) (a) CPU memory addresses/pointers NOT checked for NULL.
N*
N*                   (b) CPU memory addresses/buffers  NOT checked for overlapping.
N*
N*                       (1) IEEE Std 1003.1, 2004 Edition, Section 'memcpy() : DESCRIPTION' states that
N*                           "copying ... between objects that overlap ... is undefined".
N*
N*               (3) MEM_VAL_COPY_SET_xxx() macro's copy/encode data values without regard to CPU word-aligned
N*                   addresses.  Thus for processors that require data word alignment, data words can be copied/
N*                   encoded to/from any CPU address, word-aligned or not, without generating data-word-alignment
N*                   exceptions/faults.
N*
N*               (4) MEM_VAL_COPY_SET_xxx() macro's are more efficient than MEM_VAL_SET_xxx() macro's & are
N*                   also independent of CPU data-word-alignment & SHOULD be used whenever possible.
N*
N*                   See also 'MEM_VAL_SET_xxx()  Note #4'.
N*
N*               (5) Since octet-order copy/conversion are inverse operations, MEM_VAL_COPY_GET_xxx() &
N*                   MEM_VAL_COPY_SET_xxx() macros are inverse, but identical, operations & are provided
N*                   in both forms for semantics & consistency.
N*
N*                   See also 'MEM_VAL_COPY_GET_xxx()  Note #5'.
N*
N*               (6) MEM_VAL_COPY_SET_xxx() macro's are NOT atomic operations & MUST NOT be used on any
N*                   non-static (i.e. volatile) variables, registers, hardware, etc.; without the caller
N*                   of the  macro's providing some form of additional protection (e.g. mutual exclusion).
N*********************************************************************************************************
N*/
N
N                                                                        /* See Note #5.                                 */
N#define  MEM_VAL_COPY_SET_INT08U_BIG(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT08U_BIG(addr_dest, addr_src)
N#define  MEM_VAL_COPY_SET_INT16U_BIG(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT16U_BIG(addr_dest, addr_src)
N#define  MEM_VAL_COPY_SET_INT32U_BIG(addr_dest, addr_src)               MEM_VAL_COPY_GET_INT32U_BIG(addr_dest, addr_src)
N
N#define  MEM_VAL_COPY_SET_INT08U_LITTLE(addr_dest, addr_src)            MEM_VAL_COPY_GET_INT08U_LITTLE(addr_dest, addr_src)
N#define  MEM_VAL_COPY_SET_INT16U_LITTLE(addr_dest, addr_src)            MEM_VAL_COPY_GET_INT16U_LITTLE(addr_dest, addr_src)
N#define  MEM_VAL_COPY_SET_INT32U_LITTLE(addr_dest, addr_src)            MEM_VAL_COPY_GET_INT32U_LITTLE(addr_dest, addr_src)
N
N
N#define  MEM_VAL_COPY_SET_INT08U(addr_dest, addr_src)                   MEM_VAL_COPY_GET_INT08U(addr_dest, addr_src)
N#define  MEM_VAL_COPY_SET_INT16U(addr_dest, addr_src)                   MEM_VAL_COPY_GET_INT16U(addr_dest, addr_src)
N#define  MEM_VAL_COPY_SET_INT32U(addr_dest, addr_src)                   MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                     MEM_VAL_COPY_SET_INTU_xxx()
N*
N* Description : Copy & encode data values from any CPU memory address to any CPU memory address for
N*                   any sized data values.
N*
N* Argument(s) : addr_dest       Lowest CPU memory address to copy/encode source address's data value
N*                                   (see Notes #2 & #3).
N*
N*               addr_src        Lowest CPU memory address of data value to copy/encode
N*                                   (see Notes #2 & #3).
N*
N*               val_size        Number of data value octets to copy/encode.
N*
N* Return(s)   : none.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) Copy/encode data values based on the values' data-word order :
N*
N*                       MEM_VAL_COPY_SET_INTU_BIG()     Encode big-   endian data values -- data words' most
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_COPY_SET_INTU_LITTLE()  Encode little-endian data values -- data words' least
N*                                                           significant octet @ lowest memory address
N*                       MEM_VAL_COPY_SET_INTU()         Encode data values using CPU's native or configured
N*                                                           data-word order
N*
N*                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
N*
N*               (2) (a) CPU memory addresses/pointers NOT checked for NULL.
N*
N*                   (b) CPU memory addresses/buffers  NOT checked for overlapping.
N*
N*                       (1) IEEE Std 1003.1, 2004 Edition, Section 'memcpy() : DESCRIPTION' states that
N*                           "copying ... between objects that overlap ... is undefined".
N*
N*               (3) MEM_VAL_COPY_SET_INTU_xxx() macro's copy/encode data values without regard to CPU word-
N*                   aligned addresses.  Thus for processors that require data word alignment, data words
N*                   can be copied/encoded to/from any CPU address, word-aligned or not, without generating
N*                   data-word-alignment exceptions/faults.
N*
N*               (4) MEM_VAL_COPY_SET_xxx() macro's are more efficient than MEM_VAL_COPY_SET_INTU_xxx()
N*                   macro's & SHOULD be used whenever possible.
N*
N*                   See also 'MEM_VAL_COPY_SET_xxx()  Note #4'.
N*
N*               (5) Since octet-order copy/conversion are inverse operations, MEM_VAL_COPY_GET_INTU_xxx() &
N*                   MEM_VAL_COPY_SET_INTU_xxx() macros are inverse, but identical, operations & are provided
N*                   in both forms for semantics & consistency.
N*
N*                   See also 'MEM_VAL_COPY_GET_INTU_xxx()  Note #5'.
N*
N*               (6) MEM_VAL_COPY_SET_INTU_xxx() macro's are NOT atomic operations & MUST NOT be used on any
N*                   non-static (i.e. volatile) variables, registers, hardware, etc.; without the caller of
N*                   the macro's providing some form of additional protection (e.g. mutual exclusion).
N*********************************************************************************************************
N*/
N
N                                                                        /* See Note #5.                                 */
N#define  MEM_VAL_COPY_SET_INTU_BIG(addr_dest, addr_src, val_size)       MEM_VAL_COPY_GET_INTU_BIG(addr_dest, addr_src, val_size)
N#define  MEM_VAL_COPY_SET_INTU_LITTLE(addr_dest, addr_src, val_size)    MEM_VAL_COPY_GET_INTU_LITTLE(addr_dest, addr_src, val_size)
N#define  MEM_VAL_COPY_SET_INTU(addr_dest, addr_src, val_size)           MEM_VAL_COPY_GET_INTU(addr_dest, addr_src, val_size)
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         MEM_VAL_COPY_xxx()
N*
N* Description : Copy data values from any CPU memory address to any CPU memory address.
N*
N* Argument(s) : addr_dest       Lowest CPU memory address to copy source address's data value
N*                                   (see Notes #2 & #3).
N*
N*               addr_src        Lowest CPU memory address of data value to copy
N*                                   (see Notes #2 & #3).
N*
N*               val_size        Number of data value octets to copy.
N*
N* Return(s)   : none.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) MEM_VAL_COPY_xxx() macro's copy data values based on CPU's native data-word order.
N*
N*                   See also 'cpu.h  CPU WORD CONFIGURATION  Note #2'.
N*
N*               (2) (a) CPU memory addresses/pointers NOT checked for NULL.
N*
N*                   (b) CPU memory addresses/buffers  NOT checked for overlapping.
N*
N*                       (1) IEEE Std 1003.1, 2004 Edition, Section 'memcpy() : DESCRIPTION' states that
N*                           "copying ... between objects that overlap ... is undefined".
N*
N*               (3) MEM_VAL_COPY_xxx() macro's copy data values without regard to CPU word-aligned addresses.
N*                   Thus for processors that require data word alignment, data words can be copied to/from any
N*                   CPU address, word-aligned or not, without generating data-word-alignment exceptions/faults.
N*
N*               (4) MEM_VAL_COPY_xxx() macro's are more efficient than MEM_VAL_COPY() macro & SHOULD be
N*                   used whenever possible.
N*
N*               (5) MEM_VAL_COPY_xxx() macro's are NOT atomic operations & MUST NOT be used on any non-static
N*                   (i.e. volatile) variables, registers, hardware, etc.; without the caller of the macro's
N*                   providing some form of additional protection (e.g. mutual exclusion).
N*
N*               (6) MISRA-C 2004 Rule 5.2 states that "identifiers in an inner scope shall not use the same
N*                   name as an indentifier in an outer scope, and therefore hide that identifier".
N*
N*                   Therefore, to avoid possible redeclaration of commonly-used loop counter identifier name,
N*                   'i', MEM_VAL_COPY() loop counter identifier name is prefixed with a single underscore.
N*********************************************************************************************************
N*/
N
N#define  MEM_VAL_COPY_08(addr_dest, addr_src)                  do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); } while (0)
N
N#define  MEM_VAL_COPY_16(addr_dest, addr_src)                  do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); } while (0)
X#define  MEM_VAL_COPY_16(addr_dest, addr_src)                  do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); } while (0)
N
N#define  MEM_VAL_COPY_32(addr_dest, addr_src)                  do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2)); \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); } while (0)
X#define  MEM_VAL_COPY_32(addr_dest, addr_src)                  do { (*(((CPU_INT08U *)(addr_dest)) + 0)) = (*(((CPU_INT08U *)(addr_src)) + 0));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 1)) = (*(((CPU_INT08U *)(addr_src)) + 1));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 2)) = (*(((CPU_INT08U *)(addr_src)) + 2));                                                                     (*(((CPU_INT08U *)(addr_dest)) + 3)) = (*(((CPU_INT08U *)(addr_src)) + 3)); } while (0)
N
N
N#define  MEM_VAL_COPY(addr_dest, addr_src, val_size)        do {                                                                                \
N                                                                CPU_SIZE_T  _i;                                                                 \
N                                                                                                                                                \
N                                                                for (_i = 0; _i < (val_size); _i++) {                                           \
N                                                                    (*(((CPU_INT08U *)(addr_dest)) +_i)) = (*(((CPU_INT08U *)(addr_src)) +_i)); \
N                                                                }                                                                               \
N                                                            } while (0)
X#define  MEM_VAL_COPY(addr_dest, addr_src, val_size)        do {                                                                                                                                                CPU_SIZE_T  _i;                                                                                                                                                                                                                                                                                 for (_i = 0; _i < (val_size); _i++) {                                                                                                               (*(((CPU_INT08U *)(addr_dest)) +_i)) = (*(((CPU_INT08U *)(addr_src)) +_i));                                                                 }                                                                                                                                           } while (0)
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         FUNCTION PROTOTYPES
N*********************************************************************************************************
N*/
N
Nvoid               Mem_Init              (       void);
N
N                                                                    /* ---------------- MEM API  FNCTS ---------------- */
Nvoid               Mem_Clr               (       void              *pmem,
N                                                 CPU_SIZE_T         size);
N
Nvoid               Mem_Set               (       void              *pmem,
N                                                 CPU_INT08U         data_val,
N                                                 CPU_SIZE_T         size);
N
Nvoid               Mem_Copy              (       void              *pdest,
N                                          const  void              *psrc,
N                                                 CPU_SIZE_T         size);
N
Nvoid               Mem_Move              (       void              *pdest,
N                                          const  void              *psrc,
N                                                 CPU_SIZE_T         size);
N
NCPU_BOOLEAN        Mem_Cmp               (const  void              *p1_mem,
N                                          const  void              *p2_mem,
N                                                 CPU_SIZE_T         size);
N
N
N
N#if (LIB_MEM_CFG_ALLOC_EN == DEF_ENABLED)                           /* ---------------- MEM POOL FNCTS ---------------- */
X#if (1u == 1u)
N
Nvoid              *Mem_HeapAlloc         (       CPU_SIZE_T         size,
N                                                 CPU_SIZE_T         align,
N                                                 CPU_SIZE_T        *poctets_reqd,
N                                                 LIB_ERR           *perr);
N
NCPU_SIZE_T         Mem_HeapGetSizeRem    (       CPU_SIZE_T         align,
N                                                 LIB_ERR           *perr);
N
N
NCPU_SIZE_T         Mem_SegGetSizeRem     (       MEM_POOL          *pmem_pool,
N                                                 CPU_SIZE_T         align,
N                                                 LIB_ERR           *perr);
N
N
Nvoid               Mem_PoolClr           (       MEM_POOL          *pmem_pool,
N                                                 LIB_ERR           *perr);
N
Nvoid               Mem_PoolCreate        (       MEM_POOL          *pmem_pool,
N                                                 void              *pmem_base_addr,
N                                                 CPU_SIZE_T         mem_size,
N                                                 MEM_POOL_BLK_QTY   blk_nbr,
N                                                 CPU_SIZE_T         blk_size,
N                                                 CPU_SIZE_T         blk_align,
N                                                 CPU_SIZE_T        *poctets_reqd,
N                                                 LIB_ERR           *perr);
N
N
NMEM_POOL_BLK_QTY   Mem_PoolBlkGetNbrAvail(       MEM_POOL          *pmem_pool,
N                                                 LIB_ERR           *perr);
N
Nvoid              *Mem_PoolBlkGet        (       MEM_POOL          *pmem_pool,
N                                                 CPU_SIZE_T         size,
N                                                 LIB_ERR           *perr);
N
Nvoid              *Mem_PoolBlkGetUsedAtIx(       MEM_POOL          *pmem_pool,
N                                                 MEM_POOL_IX        used_ix,
N                                                 LIB_ERR           *perr);
N
Nvoid               Mem_PoolBlkFree       (       MEM_POOL          *pmem_pool,
N                                                 void              *pmem_blk,
N                                                 LIB_ERR           *perr);
N
NMEM_POOL_IX        Mem_PoolBlkIxGet      (       MEM_POOL          *pmem_pool,
N                                                 void              *pmem_blk,
N                                                 LIB_ERR           *perr);
N
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N#ifndef  LIB_MEM_CFG_ARG_CHK_EXT_EN
S#error  "LIB_MEM_CFG_ARG_CHK_EXT_EN         not #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  DEF_DISABLED]           "
S#error  "                             [     ||  DEF_ENABLED ]           "
S
S#elif  ((LIB_MEM_CFG_ARG_CHK_EXT_EN != DEF_DISABLED) && \
S        (LIB_MEM_CFG_ARG_CHK_EXT_EN != DEF_ENABLED ))
X#elif  ((1u != 0u) &&         (1u != 1u ))
S#error  "LIB_MEM_CFG_ARG_CHK_EXT_EN   illegally #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  DEF_DISABLED]           "
S#error  "                             [     ||  DEF_ENABLED ]           "
N#endif
N
N
N
N#ifndef  LIB_MEM_CFG_OPTIMIZE_ASM_EN
S#error  "LIB_MEM_CFG_OPTIMIZE_ASM_EN        not #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  DEF_DISABLED]           "
S#error  "                             [     ||  DEF_ENABLED ]           "
S
S#elif  ((LIB_MEM_CFG_OPTIMIZE_ASM_EN != DEF_DISABLED) && \
S        (LIB_MEM_CFG_OPTIMIZE_ASM_EN != DEF_ENABLED ))
X#elif  ((1u != 0u) &&         (1u != 1u ))
S#error  "LIB_MEM_CFG_OPTIMIZE_ASM_EN  illegally #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  DEF_DISABLED]           "
S#error  "                             [     ||  DEF_ENABLED ]           "
N#endif
N
N
N
N
N#ifndef  LIB_MEM_CFG_ALLOC_EN
S#error  "LIB_MEM_CFG_ALLOC_EN               not #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  DEF_DISABLED]           "
S#error  "                             [     ||  DEF_ENABLED ]           "
S
S#elif  ((LIB_MEM_CFG_ALLOC_EN != DEF_DISABLED) && \
S        (LIB_MEM_CFG_ALLOC_EN != DEF_ENABLED ))
X#elif  ((1u != 0u) &&         (1u != 1u ))
S#error  "LIB_MEM_CFG_ALLOC_EN         illegally #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  DEF_DISABLED]           "
S#error  "                             [     ||  DEF_ENABLED ]           "
S
S
N#elif   (LIB_MEM_CFG_ALLOC_EN == DEF_ENABLED)
X#elif   (1u == 1u)
N
N
N#ifndef  LIB_MEM_CFG_HEAP_SIZE
S#error  "LIB_MEM_CFG_HEAP_SIZE              not #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  > 0]                    "
S
S#elif   (DEF_CHK_VAL_MIN(LIB_MEM_CFG_HEAP_SIZE, 1) != DEF_OK)
X#elif   ((((!(((23u * 1024u) >= 1) && ((1) < 1))) && ((((1) >= 1) && ((23u * 1024u) < 1)) || ((23u * 1024u) < (1)))) ? 0u : 1u) != 1u)
S#error  "LIB_MEM_CFG_HEAP_SIZE        illegally #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  > 0]                    "
N#endif
N
N
N#ifdef   LIB_MEM_CFG_HEAP_BASE_ADDR
S#if     (LIB_MEM_CFG_HEAP_BASE_ADDR == 0x0)
S#error  "LIB_MEM_CFG_HEAP_BASE_ADDR   illegally #define'd in 'lib_cfg.h'"
S#error  "                             [MUST be  > 0x0]                  "
S#endif
N#endif
N
N
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                    LIBRARY CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N                                                                /* See 'lib_mem.h  Note #2a'.                           */
N#if     (CPU_CORE_VERSION < 127u)
X#if     (12901u < 127u)
S#error  "CPU_CORE_VERSION  [SHOULD be >= V1.27]"
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*
N* Note(s) : (1) See 'lib_mem.h  MODULE'.
N*********************************************************************************************************
N*/
N
N#endif                                                          /* End of lib mem module include.                       */
N
L 110 "..\..\uCOS-III\uC-CPU\cpu_core.h" 2
N#include  <lib_str.h>
L 1 "..\..\uCOS-III\uC-LIB\lib_str.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/LIB
N*                                        CUSTOM LIBRARY MODULES
N*
N*                          (c) Copyright 2004-2012; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/LIB is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                       ASCII STRING MANAGEMENT
N*
N* Filename      : lib_str.h
N* Version       : V1.37.01
N* Programmer(s) : ITJ
N*                 JDH
N*********************************************************************************************************
N* Note(s)       : (1) NO compiler-supplied standard library functions are used in library or product software.
N*
N*                     (a) ALL standard library functions are implemented in the custom library modules :
N*
N*                         (1) \<Custom Library Directory>\lib_*.*
N*
N*                         (2) \<Custom Library Directory>\Ports\<cpu>\<compiler>\lib*_a.*
N*
N*                               where
N*                                       <Custom Library Directory>      directory path for custom library software
N*                                       <cpu>                           directory name for specific processor (CPU)
N*                                       <compiler>                      directory name for specific compiler
N*
N*                     (b) Product-specific library functions are implemented in individual products.
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*
N* Note(s) : (1) This string library header file is protected from multiple pre-processor inclusion through
N*               use of the string library module present pre-processor macro definition.
N*********************************************************************************************************
N*/
N
N#ifndef  LIB_STR_MODULE_PRESENT                                 /* See Note #1.                                         */
N#define  LIB_STR_MODULE_PRESENT
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                 ASCII STRING CONFIGURATION DEFINES
N*
N* Note(s) : (1) Some ASCII string configuration #define's MUST be available PRIOR to including any
N*               application configuration (see 'INCLUDE FILES  Note #1a').
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                    STRING FLOATING POINT DEFINES
N*
N* Note(s) : (1) (a) (1) The maximum accuracy for 32-bit floating-point numbers :
N*
N*
N*                             Maximum Accuracy            log [Internal-Base ^ (Number-Internal-Base-Digits)]
N*                       32-bit Floating-point Number  =  -----------------------------------------------------
N*                                                                         log [External-Base]
N*
N*                                                         log [2 ^ 24]
N*                                                     =  --------------
N*                                                           log [10]
N*
N*                                                     <  7.225  Base-10 Digits
N*
N*                           where
N*                                   Internal-Base                   Internal number base of floating-
N*                                                                       point numbers (i.e.  2)
N*                                   External-Base                   External number base of floating-
N*                                                                       point numbers (i.e. 10)
N*                                   Number-Internal-Base-Digits     Number of internal number base
N*                                                                       significant digits (i.e. 24)
N*
N*                   (2) Also, since some 32-bit floating-point calculations are converted to 32-bit
N*                       unsigned numbers, the maximum accuracy is limited to the maximum accuracy
N*                       for 32-bit unsigned numbers of 9 digits.
N*
N*               (b) Some CPUs' &/or compilers' floating-point implementations MAY further reduce the
N*                   maximum accuracy.
N*********************************************************************************************************
N*/
N
N#define  LIB_STR_FP_MAX_NBR_DIG_SIG_MIN                    1u
N#define  LIB_STR_FP_MAX_NBR_DIG_SIG_MAX                    9u   /* See Note #1a2.                                       */
N#define  LIB_STR_FP_MAX_NBR_DIG_SIG_DFLT                   7u   /* See Note #1a1.                                       */
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                            INCLUDE FILES
N*
N* Note(s) : (1) The custom library software files are located in the following directories :
N*
N*               (a) \<Your Product Application>\lib_cfg.h
N*
N*               (b) \<Custom Library Directory>\lib_*.*
N*
N*                       where
N*                               <Your Product Application>      directory path for Your Product's Application
N*                               <Custom Library Directory>      directory path for custom library software
N*
N*           (2) CPU-configuration  software files are located in the following directories :
N*
N*               (a) \<CPU-Compiler Directory>\cpu_*.*
N*               (b) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*
N*
N*                       where
N*                               <CPU-Compiler Directory>        directory path for common CPU-compiler software
N*                               <cpu>                           directory name for specific processor (CPU)
N*                               <compiler>                      directory name for specific compiler
N*
N*           (3) Compiler MUST be configured to include as additional include path directories :
N*
N*               (a) '\<Your Product Application>\' directory                            See Note #1a
N*
N*               (b) '\<Custom Library Directory>\' directory                            See Note #1b
N*
N*               (c) (1) '\<CPU-Compiler Directory>\'                  directory         See Note #2a
N*                   (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory         See Note #2b
N*
N*           (4) NO compiler-supplied standard library functions SHOULD be used.
N*
N*               #### The reference to standard library header files SHOULD be removed once all custom
N*               library functions are implemented WITHOUT reference to ANY standard library function(s).
N*
N*               See also 'STANDARD LIBRARY MACRO'S  Note #1'.
N*********************************************************************************************************
N*/
N
N#include  <cpu.h>
N
N#include  <lib_def.h>
N#include  <lib_ascii.h>
L 1 "..\..\uCOS-III\uC-LIB\lib_ascii.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/LIB
N*                                        CUSTOM LIBRARY MODULES
N*
N*                          (c) Copyright 2004-2012; Micrium, Inc.; Weston, FL
N*
N*               All rights reserved.  Protected by international copyright laws.
N*
N*               uC/LIB is provided in source form to registered licensees ONLY.  It is
N*               illegal to distribute this source code to any third party unless you receive
N*               written permission by an authorized Micrium representative.  Knowledge of
N*               the source code may NOT be used to develop a similar product.
N*
N*               Please help us continue to provide the Embedded community with the finest
N*               software available.  Your honesty is greatly appreciated.
N*
N*               You can contact us at www.micrium.com.
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*
N*                                     ASCII CHARACTER OPERATIONS
N*
N* Filename      : lib_ascii.h
N* Version       : V1.37.01
N* Programmer(s) : BAN
N*********************************************************************************************************
N* Note(s)       : (1) NO compiler-supplied standard library functions are used in library or product software.
N*
N*                     (a) ALL standard library functions are implemented in the custom library modules :
N*
N*                         (1) \<Custom Library Directory>\lib_*.*
N*
N*                         (2) \<Custom Library Directory>\Ports\<cpu>\<compiler>\lib*_a.*
N*
N*                               where
N*                                       <Custom Library Directory>      directory path for custom library software
N*                                       <cpu>                           directory name for specific processor (CPU)
N*                                       <compiler>                      directory name for specific compiler
N*
N*                     (b) Product-specific library functions are implemented in individual products.
N*
N*
N*                 (2) (a) ECMA-6 '7-Bit coded Character Set' (6th edition), which corresponds to the
N*                         3rd edition of ISO 646, specifies several versions of a 7-bit character set :
N*
N*                         (1) THE GENERAL VERSION, which allows characters at 0x23 and 0x24 to be given a
N*                             set alternate form and allows the characters 0x40, 0x5B, 0x5D, 0x60, 0x7B &
N*                             0x7D to be assigned a "unique graphic character" or to be declared as unused.
N*                             All other characters are explicitly specified.
N*
N*                         (2) THE INTERNATIONAL REFERENCE VERSION, which explicitly specifies all characters
N*                             in the 7-bit character set.
N*
N*                         (3) NATIONAL & APPLICATION-ORIENTED VERSIONS, which may be derived from the
N*                             standard in specified ways.
N*
N*                     (b) The character set represented in this file reproduces the Internation Reference
N*                         Version.  This is identical to the 7-bit character set which occupies Unicode
N*                         characters 0x0000 through 0x007F.  The character names are taken from v5.0 of the
N*                         Unicode specification, with certain abbreviations so that the resulting #define
N*                         names will not violate ANSI C naming restriction :
N*
N*                         (1) For the Latin capital & lowercase letters, the name components 'LETTER_CAPITAL'
N*                             & 'LETTER_SMALL' are replaced by 'UPPER' & 'LOWER', respectively.
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                               MODULE
N*
N* Note(s) : (1) This ASCII library header file is protected from multiple pre-processor inclusion through
N*               use of the ASCII library module present pre-processor macro definition.
N*********************************************************************************************************
N*/
N
N#ifndef  LIB_ASCII_MODULE_PRESENT                               /* See Note #1.                                         */
N#define  LIB_ASCII_MODULE_PRESENT
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                            INCLUDE FILES
N*
N* Note(s) : (1) The custom library software files are located in the following directories :
N*
N*               (a) \<Custom Library Directory>\lib_*.*
N*
N*                       where
N*                               <Custom Library Directory>      directory path for custom library software
N*
N*           (2) CPU-configuration  software files are located in the following directories :
N*
N*               (a) \<CPU-Compiler Directory>\cpu_*.*
N*               (b) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*
N*
N*                       where
N*                               <CPU-Compiler Directory>        directory path for common CPU-compiler software
N*                               <cpu>                           directory name for specific processor (CPU)
N*                               <compiler>                      directory name for specific compiler
N*
N*           (3) Compiler MUST be configured to include as additional include path directories :
N*
N*               (a) '\<Custom Library Directory>\' directory                            See Note #1a
N*
N*               (b) (1) '\<CPU-Compiler Directory>\'                  directory         See Note #2a
N*                   (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory         See Note #2b
N*
N*           (4) NO compiler-supplied standard library functions SHOULD be used.
N*********************************************************************************************************
N*/
N
N#include  <cpu.h>
N#include  <lib_def.h>
N
N
N/*
N*********************************************************************************************************
N*                                               EXTERNS
N*********************************************************************************************************
N*/
N
N#ifdef   LIB_ASCII_MODULE
S#define  LIB_ASCII_EXT
N#else
N#define  LIB_ASCII_EXT  extern
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                               DEFINES
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                         ASCII CHARACTER DEFINES
N*********************************************************************************************************
N*/
N
N                                                                /* -------------------- C0 CONTROLS ------------------- */
N#define  ASCII_CHAR_NULL                                0x00    /* '\0'                                                 */
N#define  ASCII_CHAR_START_OF_HEADING                    0x01
N#define  ASCII_CHAR_START_OF_TEXT                       0x02
N#define  ASCII_CHAR_END_OF_TEXT                         0x03
N#define  ASCII_CHAR_END_OF_TRANSMISSION                 0x04
N#define  ASCII_CHAR_ENQUIRY                             0x05
N#define  ASCII_CHAR_ACKNOWLEDGE                         0x06
N#define  ASCII_CHAR_BELL                                0x07    /* '\a'                                                 */
N#define  ASCII_CHAR_BACKSPACE                           0x08    /* '\b'                                                 */
N#define  ASCII_CHAR_CHARACTER_TABULATION                0x09    /* '\t'                                                 */
N#define  ASCII_CHAR_LINE_FEED                           0x0A    /* '\n'                                                 */
N#define  ASCII_CHAR_LINE_TABULATION                     0x0B    /* '\v'                                                 */
N#define  ASCII_CHAR_FORM_FEED                           0x0C    /* '\f'                                                 */
N#define  ASCII_CHAR_CARRIAGE_RETURN                     0x0D    /* '\r'                                                 */
N#define  ASCII_CHAR_SHIFT_OUT                           0x0E
N#define  ASCII_CHAR_SHIFT_IN                            0x0F
N#define  ASCII_CHAR_DATA_LINK_ESCAPE                    0x10
N#define  ASCII_CHAR_DEVICE_CONTROL_ONE                  0x11
N#define  ASCII_CHAR_DEVICE_CONTROL_TWO                  0x12
N#define  ASCII_CHAR_DEVICE_CONTROL_THREE                0x13
N#define  ASCII_CHAR_DEVICE_CONTROL_FOUR                 0x14
N#define  ASCII_CHAR_NEGATIVE_ACKNOWLEDGE                0x15
N#define  ASCII_CHAR_SYNCHRONOUS_IDLE                    0x16
N#define  ASCII_CHAR_END_OF_TRANSMISSION_BLOCK           0x17
N#define  ASCII_CHAR_CANCEL                              0x18
N#define  ASCII_CHAR_END_OF_MEDIUM                       0x19
N#define  ASCII_CHAR_SUBSITUTE                           0x1A
N#define  ASCII_CHAR_ESCAPE                              0x1B
N#define  ASCII_CHAR_INFO_SEPARATOR_FOUR                 0x1C
N#define  ASCII_CHAR_INFO_SEPARATOR_THREE                0x1D
N#define  ASCII_CHAR_INFO_SEPARATOR_TWO                  0x1E
N#define  ASCII_CHAR_INFO_SEPARATOR_ONE                  0x1F
N
N#define  ASCII_CHAR_NUL                                 ASCII_CHAR_NULL
N#define  ASCII_CHAR_SOH                                 ASCII_CHAR_START_OF_HEADING
N#define  ASCII_CHAR_START_HEADING                       ASCII_CHAR_START_OF_HEADING
N#define  ASCII_CHAR_STX                                 ASCII_CHAR_START_OF_TEXT
N#define  ASCII_CHAR_START_TEXT                          ASCII_CHAR_START_OF_TEXT
N#define  ASCII_CHAR_ETX                                 ASCII_CHAR_END_OF_TEXT
N#define  ASCII_CHAR_END_TEXT                            ASCII_CHAR_END_OF_TEXT
N#define  ASCII_CHAR_EOT                                 ASCII_CHAR_END_OF_TRANSMISSION
N#define  ASCII_CHAR_END_TRANSMISSION                    ASCII_CHAR_END_OF_TRANSMISSION
N#define  ASCII_CHAR_ENQ                                 ASCII_CHAR_ENQUIRY
N#define  ASCII_CHAR_ACK                                 ASCII_CHAR_ACKNOWLEDGE
N#define  ASCII_CHAR_BEL                                 ASCII_CHAR_BELL
N#define  ASCII_CHAR_BS                                  ASCII_CHAR_BACKSPACE
N#define  ASCII_CHAR_HT                                  ASCII_CHAR_CHARACTER_TABULATION
N#define  ASCII_CHAR_TAB                                 ASCII_CHAR_CHARACTER_TABULATION
N#define  ASCII_CHAR_LF                                  ASCII_CHAR_LINE_FEED
N#define  ASCII_CHAR_VT                                  ASCII_CHAR_LINE_TABULATION
N#define  ASCII_CHAR_FF                                  ASCII_CHAR_FORM_FEED
N#define  ASCII_CHAR_CR                                  ASCII_CHAR_CARRIAGE_RETURN
N#define  ASCII_CHAR_SO                                  ASCII_CHAR_SHIFT_OUT
N#define  ASCII_CHAR_SI                                  ASCII_CHAR_SHIFT_IN
N#define  ASCII_CHAR_DLE                                 ASCII_CHAR_DATA_LINK_ESCAPE
N#define  ASCII_CHAR_DC1                                 ASCII_CHAR_DEVICE_CONTROL_ONE
N#define  ASCII_CHAR_DC2                                 ASCII_CHAR_DEVICE_CONTROL_TWO
N#define  ASCII_CHAR_DC3                                 ASCII_CHAR_DEVICE_CONTROL_THREE
N#define  ASCII_CHAR_DC4                                 ASCII_CHAR_DEVICE_CONTROL_FOUR
N#define  ASCII_CHAR_DEV_CTRL_ONE                        ASCII_CHAR_DEVICE_CONTROL_ONE
N#define  ASCII_CHAR_DEV_CTRL_TWO                        ASCII_CHAR_DEVICE_CONTROL_TWO
N#define  ASCII_CHAR_DEV_CTRL_THREE                      ASCII_CHAR_DEVICE_CONTROL_THREE
N#define  ASCII_CHAR_DEV_CTRL_FOUR                       ASCII_CHAR_DEVICE_CONTROL_FOUR
N#define  ASCII_CHAR_NAK                                 ASCII_CHAR_NEGATIVE_ACKNOWLEDGE
N#define  ASCII_CHAR_NEG_ACK                             ASCII_CHAR_NEGATIVE_ACKNOWLEDGE
N#define  ASCII_CHAR_SYN                                 ASCII_CHAR_SYNCHRONOUS_IDLE
N#define  ASCII_CHAR_SYNC_IDLE                           ASCII_CHAR_SYNCHRONOUS_IDLE
N#define  ASCII_CHAR_ETB                                 ASCII_CHAR_END_OF_TRANSMISSION_BLOCK
N#define  ASCII_CHAR_END_TRANSMISSION_BLK                ASCII_CHAR_END_OF_TRANSMISSION_BLOCK
N#define  ASCII_CHAR_CAN                                 ASCII_CHAR_CANCEL
N#define  ASCII_CHAR_EM                                  ASCII_CHAR_END_OF_MEDIUM
N#define  ASCII_CHAR_END_MEDIUM                          ASCII_CHAR_END_OF_MEDIUM
N#define  ASCII_CHAR_SUB                                 ASCII_CHAR_SUBSITUTE
N#define  ASCII_CHAR_ESC                                 ASCII_CHAR_ESCAPE
N#define  ASCII_CHAR_IS1                                 ASCII_CHAR_INFO_SEPARATOR_ONE
N#define  ASCII_CHAR_IS2                                 ASCII_CHAR_INFO_SEPARATOR_TWO
N#define  ASCII_CHAR_IS3                                 ASCII_CHAR_INFO_SEPARATOR_THREE
N#define  ASCII_CHAR_IS4                                 ASCII_CHAR_INFO_SEPARATOR_FOUR
N
N
N/*$PAGE*/
N                                                                /* ------------ ASCII PUNCTUATION & SYMBOLS ----------- */
N#define  ASCII_CHAR_SPACE                               0x20    /* ' '                                                  */
N#define  ASCII_CHAR_EXCLAMATION_MARK                    0x21    /* '!'                                                  */
N#define  ASCII_CHAR_QUOTATION_MARK                      0x22    /* '\"'                                                 */
N#define  ASCII_CHAR_NUMBER_SIGN                         0x23    /* '#'                                                  */
N#define  ASCII_CHAR_DOLLAR_SIGN                         0x24    /* '$'                                                  */
N#define  ASCII_CHAR_PERCENTAGE_SIGN                     0x25    /* '%'                                                  */
N#define  ASCII_CHAR_AMPERSAND                           0x26    /* '&'                                                  */
N#define  ASCII_CHAR_APOSTROPHE                          0x27    /* '\''                                                 */
N#define  ASCII_CHAR_LEFT_PARENTHESIS                    0x28    /* '('                                                  */
N#define  ASCII_CHAR_RIGHT_PARENTHESIS                   0x29    /* ')'                                                  */
N#define  ASCII_CHAR_ASTERISK                            0x2A    /* '*'                                                  */
N#define  ASCII_CHAR_PLUS_SIGN                           0x2B    /* '+'                                                  */
N#define  ASCII_CHAR_COMMA                               0x2C    /* ','                                                  */
N#define  ASCII_CHAR_HYPHEN_MINUS                        0x2D    /* '-'                                                  */
N#define  ASCII_CHAR_FULL_STOP                           0x2E    /* '.'                                                  */
N#define  ASCII_CHAR_SOLIDUS                             0x2F    /* '/'                                                  */
N
N#define  ASCII_CHAR_PAREN_LEFT                          ASCII_CHAR_LEFT_PARENTHESIS
N#define  ASCII_CHAR_PAREN_RIGHT                         ASCII_CHAR_RIGHT_PARENTHESIS
N
N
N                                                                /* ------------------- ASCII DIGITS ------------------- */
N#define  ASCII_CHAR_DIGIT_ZERO                          0x30    /* '0'                                                  */
N#define  ASCII_CHAR_DIGIT_ONE                           0x31    /* '1'                                                  */
N#define  ASCII_CHAR_DIGIT_TWO                           0x32    /* '2'                                                  */
N#define  ASCII_CHAR_DIGIT_THREE                         0x33    /* '3'                                                  */
N#define  ASCII_CHAR_DIGIT_FOUR                          0x34    /* '4'                                                  */
N#define  ASCII_CHAR_DIGIT_FIVE                          0x35    /* '5'                                                  */
N#define  ASCII_CHAR_DIGIT_SIX                           0x36    /* '6'                                                  */
N#define  ASCII_CHAR_DIGIT_SEVEN                         0x37    /* '7'                                                  */
N#define  ASCII_CHAR_DIGIT_EIGHT                         0x38    /* '8'                                                  */
N#define  ASCII_CHAR_DIGIT_NINE                          0x39    /* '9'                                                  */
N
N#define  ASCII_CHAR_DIG_ZERO                            ASCII_CHAR_DIGIT_ZERO
N#define  ASCII_CHAR_DIG_ONE                             ASCII_CHAR_DIGIT_ONE
N#define  ASCII_CHAR_DIG_TWO                             ASCII_CHAR_DIGIT_TWO
N#define  ASCII_CHAR_DIG_THREE                           ASCII_CHAR_DIGIT_THREE
N#define  ASCII_CHAR_DIG_FOUR                            ASCII_CHAR_DIGIT_FOUR
N#define  ASCII_CHAR_DIG_FIVE                            ASCII_CHAR_DIGIT_FIVE
N#define  ASCII_CHAR_DIG_SIX                             ASCII_CHAR_DIGIT_SIX
N#define  ASCII_CHAR_DIG_SEVEN                           ASCII_CHAR_DIGIT_SEVEN
N#define  ASCII_CHAR_DIG_EIGHT                           ASCII_CHAR_DIGIT_EIGHT
N#define  ASCII_CHAR_DIG_NINE                            ASCII_CHAR_DIGIT_NINE
N
N
N                                                                /* ------------ ASCII PUNCTUATION & SYMBOLS ----------- */
N#define  ASCII_CHAR_COLON                               0x3A    /* ':'                                                  */
N#define  ASCII_CHAR_SEMICOLON                           0x3B    /* ';'                                                  */
N#define  ASCII_CHAR_LESS_THAN_SIGN                      0x3C    /* '<'                                                  */
N#define  ASCII_CHAR_EQUALS_SIGN                         0x3D    /* '='                                                  */
N#define  ASCII_CHAR_GREATER_THAN_SIGN                   0x3E    /* '>'                                                  */
N#define  ASCII_CHAR_QUESTION_MARK                       0x3F    /* '\?'                                                 */
N#define  ASCII_CHAR_COMMERCIAL_AT                       0x40    /* '@'                                                  */
N
N#define  ASCII_CHAR_AT_SIGN                             ASCII_CHAR_COMMERCIAL_AT
N
N
N/*$PAGE*/
N                                                                /* ------------- UPPERCASE LATIN ALPHABET ------------- */
N#define  ASCII_CHAR_LATIN_UPPER_A                       0x41    /* 'A'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_B                       0x42    /* 'B'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_C                       0x43    /* 'C'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_D                       0x44    /* 'D'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_E                       0x45    /* 'E'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_F                       0x46    /* 'F'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_G                       0x47    /* 'G'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_H                       0x48    /* 'H'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_I                       0x49    /* 'I'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_J                       0x4A    /* 'J'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_K                       0x4B    /* 'K'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_L                       0x4C    /* 'L'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_M                       0x4D    /* 'M'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_N                       0x4E    /* 'N'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_O                       0x4F    /* 'O'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_P                       0x50    /* 'P'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_Q                       0x51    /* 'Q'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_R                       0x52    /* 'R'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_S                       0x53    /* 'S'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_T                       0x54    /* 'T'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_U                       0x55    /* 'U'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_V                       0x56    /* 'V'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_W                       0x57    /* 'W'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_X                       0x58    /* 'X'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_Y                       0x59    /* 'Y'                                                  */
N#define  ASCII_CHAR_LATIN_UPPER_Z                       0x5A    /* 'Z'                                                  */
N
N
N                                                                /* ------------ ASCII PUNCTUATION & SYMBOLS ----------- */
N#define  ASCII_CHAR_LEFT_SQUARE_BRACKET                 0x5B    /* '['                                                  */
N#define  ASCII_CHAR_REVERSE_SOLIDUS                     0x5C    /* '\\'                                                 */
N#define  ASCII_CHAR_RIGHT_SQUARE_BRACKET                0x5D    /* ']'                                                  */
N#define  ASCII_CHAR_CIRCUMFLEX_ACCENT                   0x5E    /* '^'                                                  */
N#define  ASCII_CHAR_LOW_LINE                            0x5F    /* '_'                                                  */
N#define  ASCII_CHAR_GRAVE_ACCENT                        0x60    /* '`'                                                  */
N
N#define  ASCII_CHAR_BRACKET_SQUARE_LEFT                 ASCII_CHAR_LEFT_SQUARE_BRACKET
N#define  ASCII_CHAR_BRACKET_SQUARE_RIGHT                ASCII_CHAR_RIGHT_SQUARE_BRACKET
N
N
N                                                                /* ------------- LOWERCASE LATIN ALPHABET ------------- */
N#define  ASCII_CHAR_LATIN_LOWER_A                       0x61    /* 'a'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_B                       0x62    /* 'b'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_C                       0x63    /* 'c'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_D                       0x64    /* 'd'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_E                       0x65    /* 'e'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_F                       0x66    /* 'f'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_G                       0x67    /* 'g'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_H                       0x68    /* 'h'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_I                       0x69    /* 'i'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_J                       0x6A    /* 'j'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_K                       0x6B    /* 'k'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_L                       0x6C    /* 'l'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_M                       0x6D    /* 'm'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_N                       0x6E    /* 'n'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_O                       0x6F    /* 'o'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_P                       0x70    /* 'p'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_Q                       0x71    /* 'q'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_R                       0x72    /* 'r'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_S                       0x73    /* 's'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_T                       0x74    /* 't'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_U                       0x75    /* 'u'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_V                       0x76    /* 'v'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_W                       0x77    /* 'w'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_X                       0x78    /* 'x'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_Y                       0x79    /* 'y'                                                  */
N#define  ASCII_CHAR_LATIN_LOWER_Z                       0x7A    /* 'z'                                                  */
N
N
N                                                                /* ------------ ASCII PUNCTUATION & SYMBOLS ----------- */
N#define  ASCII_CHAR_LEFT_CURLY_BRACKET                  0x7B    /* '{'                                                  */
N#define  ASCII_CHAR_VERTICAL_LINE                       0x7C    /* '|'                                                  */
N#define  ASCII_CHAR_RIGHT_CURLY_BRACKET                 0x7D    /* '}'                                                  */
N#define  ASCII_CHAR_TILDE                               0x7E    /* '~'                                                  */
N
N#define  ASCII_CHAR_BRACKET_CURLY_LEFT                  ASCII_CHAR_LEFT_CURLY_BRACKET
N#define  ASCII_CHAR_BRACKET_CURLY_RIGHT                 ASCII_CHAR_RIGHT_CURLY_BRACKET
N
N
N                                                                /* ---------------- CONTROL CHARACTERS ---------------- */
N#define  ASCII_CHAR_DELETE                              0x7F
N
N#define  ASCII_CHAR_DEL                                 ASCII_CHAR_DELETE
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             DATA TYPES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                          GLOBAL VARIABLES
N*********************************************************************************************************
N*/
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                              MACRO'S
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                               ASCII CHARACTER CLASSIFICATION MACRO's
N*
N* Note(s) : (1) ISO/IEC 9899:TC2, Section 7.4.1.(1) states that "character classification functions ...
N*               return nonzero (true) if and only if the value of the argument 'c' conforms to ... the
N*               description of the function."
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                           ASCII_IS_DIG()
N*
N* Description : Determine whether a character is a decimal-digit character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a decimal-digit character.
N*
N*               DEF_NO,	 if character is NOT a decimal-digit character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) ISO/IEC 9899:TC2, Section 7.4.1.5.(2)  states that "isdigit()  ... tests for any
N*                   decimal-digit character".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_DIG(c)               ((((c) >= ASCII_CHAR_DIG_ZERO) && ((c) <= ASCII_CHAR_DIG_NINE)) ? (DEF_YES) : (DEF_NO))
N
N
N/*
N*********************************************************************************************************
N*                                         ASCII_IS_DIG_OCT()
N*
N* Description : Determine whether a character is an octal-digit character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     an octal-digit character.
N*
N*               DEF_NO,	 if character is NOT an octal-digit character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : none.
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_DIG_OCT(c)          ((((c) >= ASCII_CHAR_DIG_ZERO) && ((c) <= ASCII_CHAR_DIG_SEVEN)) ? (DEF_YES) : (DEF_NO))
N
N
N/*
N*********************************************************************************************************
N*                                         ASCII_IS_DIG_HEX()
N*
N* Description : Determine whether a character is a hexadecimal-digit character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a hexadecimal-digit character.
N*
N*               DEF_NO,	 if character is NOT a hexadecimal-digit character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) ISO/IEC 9899:TC2, Section 7.4.1.12.(2) states that "isxdigit() ... tests for any
N*                   hexadecimal-digit character".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_DIG_HEX(c)          (((((c) >= ASCII_CHAR_DIG_ZERO     ) && ((c) <= ASCII_CHAR_DIG_NINE     )) || \
N                                        (((c) >= ASCII_CHAR_LATIN_UPPER_A) && ((c) <= ASCII_CHAR_LATIN_UPPER_F)) || \
N                                        (((c) >= ASCII_CHAR_LATIN_LOWER_A) && ((c) <= ASCII_CHAR_LATIN_LOWER_F))) ? (DEF_YES) : (DEF_NO))
X#define  ASCII_IS_DIG_HEX(c)          (((((c) >= ASCII_CHAR_DIG_ZERO     ) && ((c) <= ASCII_CHAR_DIG_NINE     )) ||                                         (((c) >= ASCII_CHAR_LATIN_UPPER_A) && ((c) <= ASCII_CHAR_LATIN_UPPER_F)) ||                                         (((c) >= ASCII_CHAR_LATIN_LOWER_A) && ((c) <= ASCII_CHAR_LATIN_LOWER_F))) ? (DEF_YES) : (DEF_NO))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          ASCII_IS_LOWER()
N*
N* Description : Determine whether a character is a lowercase alphabetic character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a lowercase alphabetic character.
N*
N*               DEF_NO,	 if character is NOT a lowercase alphabetic character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) ISO/IEC 9899:TC2, Section 7.4.1.7.(2)  states that "islower() returns true only for
N*                   the lowercase letters".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_LOWER(c)             ((((c) >= ASCII_CHAR_LATIN_LOWER_A) && ((c) <= ASCII_CHAR_LATIN_LOWER_Z)) ? (DEF_YES) : (DEF_NO))
N
N
N/*
N*********************************************************************************************************
N*                                          ASCII_IS_UPPER()
N*
N* Description : Determine whether a character is an uppercase alphabetic character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     an uppercase alphabetic character.
N*
N*               DEF_NO,	 if character is NOT an uppercase alphabetic character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) ISO/IEC 9899:TC2, Section 7.4.1.11.(2) states that "isupper() returns true only for
N*                   the uppercase letters".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_UPPER(c)             ((((c) >= ASCII_CHAR_LATIN_UPPER_A) && ((c) <= ASCII_CHAR_LATIN_UPPER_Z)) ? (DEF_YES) : (DEF_NO))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          ASCII_IS_ALPHA()
N*
N* Description : Determine whether a character is an alphabetic character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     an alphabetic character.
N*
N*               DEF_NO,	 if character is NOT an alphabetic character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) ISO/IEC 9899:TC2, Section 7.4.1.2.(2) states that "isalpha() returns true only for the
N*                   characters for which isupper() or islower() is true".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_ALPHA(c)             ((((ASCII_IS_UPPER(c)) == DEF_YES) || \
N                                         ((ASCII_IS_LOWER(c)) == DEF_YES)) ? (DEF_YES) : (DEF_NO))
X#define  ASCII_IS_ALPHA(c)             ((((ASCII_IS_UPPER(c)) == DEF_YES) ||                                          ((ASCII_IS_LOWER(c)) == DEF_YES)) ? (DEF_YES) : (DEF_NO))
N
N
N/*
N*********************************************************************************************************
N*                                        ASCII_IS_ALPHA_NUM()
N*
N* Description : Determine whether a character is an alphanumeric character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     an alphanumeric character.
N*
N*               DEF_NO,	 if character is NOT an alphanumeric character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) ISO/IEC 9899:TC2, Section 7.4.1.1.(2) states that "isalnum() ... tests for any character
N*                   for which isalpha() or isdigit() is true".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_ALPHA_NUM(c)         ((((ASCII_IS_ALPHA(c)) == DEF_YES) || \
N                                         ((ASCII_IS_DIG  (c)) == DEF_YES)) ? (DEF_YES) : (DEF_NO))
X#define  ASCII_IS_ALPHA_NUM(c)         ((((ASCII_IS_ALPHA(c)) == DEF_YES) ||                                          ((ASCII_IS_DIG  (c)) == DEF_YES)) ? (DEF_YES) : (DEF_NO))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          ASCII_IS_BLANK()
N*
N* Description : Determine whether a character is a standard blank character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a standard blank character.
N*
N*               DEF_NO,	 if character is NOT a standard blank character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) ISO/IEC 9899:TC2, Section 7.4.1.3.(2) states that "isblank() returns true only for
N*                       the standard blank characters".
N*
N*                   (b) ISO/IEC 9899:TC2, Section 7.4.1.3.(2) defines "the standard blank characters" as
N*                       the "space (' '), and horizontal tab ('\t')".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_BLANK(c)             ((((c) == ASCII_CHAR_SPACE) || ((c) == ASCII_CHAR_HT)) ? (DEF_YES) : (DEF_NO))
N
N
N/*
N*********************************************************************************************************
N*                                          ASCII_IS_SPACE()
N*
N* Description : Determine whether a character is a white-space character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a white-space character.
N*
N*               DEF_NO,	 if character is NOT a white-space character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) ISO/IEC 9899:TC2, Section 7.4.1.10.(2) states that "isspace() returns true only
N*                       for the standard white-space characters".
N*
N*                   (b) ISO/IEC 9899:TC2, Section 7.4.1.10.(2) defines "the standard white-space characters"
N*                       as the "space (' '), form feed ('\f'), new-line ('\n'), carriage return ('\r'),
N*                       horizontal tab ('\t'), and vertical tab ('\v')".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_SPACE(c)             ((((c) == ASCII_CHAR_SPACE) || ((c) == ASCII_CHAR_CR) || \
N                                         ((c) == ASCII_CHAR_LF   ) || ((c) == ASCII_CHAR_FF) || \
N                                         ((c) == ASCII_CHAR_HT   ) || ((c) == ASCII_CHAR_VT)) ? (DEF_YES) : (DEF_NO))
X#define  ASCII_IS_SPACE(c)             ((((c) == ASCII_CHAR_SPACE) || ((c) == ASCII_CHAR_CR) ||                                          ((c) == ASCII_CHAR_LF   ) || ((c) == ASCII_CHAR_FF) ||                                          ((c) == ASCII_CHAR_HT   ) || ((c) == ASCII_CHAR_VT)) ? (DEF_YES) : (DEF_NO))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          ASCII_IS_PRINT()
N*
N* Description : Determine whether a character is a printing character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a printing character.
N*
N*               DEF_NO,	 if character is NOT a printing character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) ISO/IEC 9899:TC2, Section 7.4.1.8.(2) states that "isprint() ... tests for any
N*                       printing character including space (' ')".
N*
N*                   (b) ISO/IEC 9899:TC2, Section 7.4.(3), Note 169, states that in "the seven-bit US
N*                       ASCII character set, the printing characters are those whose values lie from
N*                       0x20 (space) through 0x7E (tilde)".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_PRINT(c)             ((((c) >= ASCII_CHAR_SPACE) && ((c) <= ASCII_CHAR_TILDE)) ? (DEF_YES) : (DEF_NO))
N
N
N/*
N*********************************************************************************************************
N*                                          ASCII_IS_GRAPH()
N*
N* Description : Determine whether a character is any printing character except a space character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a graphic character.
N*
N*               DEF_NO,	 if character is NOT a graphic character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) ISO/IEC 9899:TC2, Section 7.4.1.6.(2) states that "isgraph() ... tests for any
N*                       printing character except space (' ')".
N*
N*                   (b) ISO/IEC 9899:TC2, Section 7.4.(3), Note 169, states that in "the seven-bit US
N*                       ASCII character set, the printing characters are those whose values lie from
N*                       0x20 (space) through 0x7E (tilde)".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_GRAPH(c)             ((((c) >= ASCII_CHAR_EXCLAMATION_MARK) && ((c) <= ASCII_CHAR_TILDE)) ? (DEF_YES) : (DEF_NO))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          ASCII_IS_PUNCT()
N*
N* Description : Determine whether a character is a punctuation character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a punctuation character.
N*
N*               DEF_NO,	 if character is NOT a punctuation character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) ISO/IEC 9899:TC2, Section 7.4.1.9.(2) states that "ispunct() returns true for every
N*                   printing character for which neither isspace() nor isalnum() is true".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_PUNCT(c)             ((((ASCII_IS_PRINT(c)) == DEF_YES) && \
N                                         ((ASCII_IS_SPACE(c)) == DEF_NO ) && \
N                                         ((ASCII_IS_ALPHA_NUM(c)) == DEF_NO )) ? (DEF_YES) : (DEF_NO))
X#define  ASCII_IS_PUNCT(c)             ((((ASCII_IS_PRINT(c)) == DEF_YES) &&                                          ((ASCII_IS_SPACE(c)) == DEF_NO ) &&                                          ((ASCII_IS_ALPHA_NUM(c)) == DEF_NO )) ? (DEF_YES) : (DEF_NO))
N
N
N/*
N*********************************************************************************************************
N*                                           ASCII_IS_CTRL()
N*
N* Description : Determine whether a character is a control character.
N*
N* Argument(s) : c           Character to examine.
N*
N* Return(s)   : DEF_YES, if character is     a control character.
N*
N*               DEF_NO,	 if character is NOT a control character.
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) ISO/IEC 9899:TC2, Section 7.4.1.4.(2) states that "iscntrl() ... tests for any
N*                       control character".
N*
N*                   (b) ISO/IEC 9899:TC2, Section 7.4.(3), Note 169, states that in "the seven-bit US
N*                       ASCII character set, ... the control characters are those whose values lie from
N*                       0 (NUL) through 0x1F (US), and the character 0x7F (DEL)".
N*********************************************************************************************************
N*/
N
N#define  ASCII_IS_CTRL(c)             (((((CPU_INT08S)(c) >= ASCII_CHAR_NULL  ) && ((c) <= ASCII_CHAR_IS1)) || \
N                                                                                   ((c) == ASCII_CHAR_DEL))  ? (DEF_YES) : (DEF_NO))
X#define  ASCII_IS_CTRL(c)             (((((CPU_INT08S)(c) >= ASCII_CHAR_NULL  ) && ((c) <= ASCII_CHAR_IS1)) ||                                                                                    ((c) == ASCII_CHAR_DEL))  ? (DEF_YES) : (DEF_NO))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                ASCII CHARACTER CASE MAPPING MACRO's
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                          ASCII_TO_LOWER()
N*
N* Description : Convert uppercase alphabetic character to its corresponding lowercase alphabetic character.
N*
N* Argument(s) : c           Character to convert.
N*
N* Return(s)   : Lowercase equivalent of 'c', if character 'c' is an uppercase character (see Note #1b1).
N*
N*               Character 'c',               otherwise                                  (see Note #1b2).
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) ISO/IEC 9899:TC2, Section 7.4.2.1.(2) states that "tolower() ... converts an
N*                       uppercase letter to a corresponding lowercase letter".
N*
N*                   (b) ISO/IEC 9899:TC2, Section 7.4.2.1.(3) states that :
N*
N*                       (1) (A) "if the argument is a character for which isupper() is true and there are
N*                                one or more corresponding characters ... for which islower() is true," ...
N*                           (B) "tolower() ... returns one of the corresponding characters;" ...
N*
N*                       (2) "otherwise, the argument is returned unchanged."
N*********************************************************************************************************
N*/
N
N#define  ASCII_TO_LOWER(c)              (((ASCII_IS_UPPER(c)) == DEF_YES) ? ((c) + (ASCII_CHAR_LATIN_LOWER_A - ASCII_CHAR_LATIN_UPPER_A)) : (c))
N
N
N/*
N*********************************************************************************************************
N*                                          ASCII_TO_UPPER()
N*
N* Description : Convert lowercase alphabetic character to its corresponding uppercase alphabetic character.
N*
N* Argument(s) : c           Character to convert.
N*
N* Return(s)   : Uppercase equivalent of 'c', if character 'c' is a lowercase character (see Note #1b1).
N*
N*               Character 'c',               otherwise                                 (see Note #1b2).
N*
N* Caller(s)   : Application.
N*
N* Note(s)     : (1) (a) ISO/IEC 9899:TC2, Section 7.4.2.2.(2) states that "toupper() ... converts a
N*                       lowercase letter to a corresponding uppercase letter".
N*
N*                   (b) ISO/IEC 9899:TC2, Section 7.4.2.2.(3) states that :
N*
N*                       (1) (A) "if the argument is a character for which islower() is true and there are
N*                                one or more corresponding characters ... for which isupper() is true," ...
N*                           (B) "toupper() ... returns one of the corresponding characters;" ...
N*
N*                       (2) "otherwise, the argument is returned unchanged."
N*********************************************************************************************************
N*/
N
N#define  ASCII_TO_UPPER(c)              (((ASCII_IS_LOWER(c)) == DEF_YES) ? ((c) - (ASCII_CHAR_LATIN_LOWER_A - ASCII_CHAR_LATIN_UPPER_A)) : (c))
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         FUNCTION PROTOTYPES
N*********************************************************************************************************
N*/
N
NCPU_BOOLEAN  ASCII_IsAlpha   (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsAlphaNum(CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsLower   (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsUpper   (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsDig     (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsDigOct  (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsDigHex  (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsBlank   (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsSpace   (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsPrint   (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsGraph   (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsPunct   (CPU_CHAR  c);
N
NCPU_BOOLEAN  ASCII_IsCtrl    (CPU_CHAR  c);
N
N
NCPU_CHAR     ASCII_ToLower   (CPU_CHAR  c);
N
NCPU_CHAR     ASCII_ToUpper   (CPU_CHAR  c);
N
N
NCPU_BOOLEAN  ASCII_Cmp       (CPU_CHAR  c1,
N                              CPU_CHAR  c2);
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*
N* Note(s) : (1) See 'lib_ascii.h  MODULE'.
N*********************************************************************************************************
N*/
N
N#endif                                                          /* End of lib ascii module include.                     */
N
L 159 "..\..\uCOS-III\uC-LIB\lib_str.h" 2
N
N#include  <lib_cfg.h>
N
N#if 0                                                           /* See Note #4.                                         */
S#include  <stdio.h>
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                               EXTERNS
N*********************************************************************************************************
N*/
N
N#ifdef   LIB_STR_MODULE
S#define  LIB_STR_EXT
N#else
N#define  LIB_STR_EXT  extern
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        DEFAULT CONFIGURATION
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                 STRING FLOATING POINT CONFIGURATION
N*
N* Note(s) : (1) Configure LIB_STR_CFG_FP_EN to enable/disable floating point string function(s).
N*
N*           (2) Configure LIB_STR_CFG_FP_MAX_NBR_DIG_SIG to configure the maximum number of significant
N*               digits to calculate &/or display for floating point string function(s).
N*
N*               See also 'STRING FLOATING POINT DEFINES  Note #1'.
N*********************************************************************************************************
N*/
N
N                                                                /* Configure floating point feature(s) [see Note #1] :  */
N#ifndef  LIB_STR_CFG_FP_EN
N#define  LIB_STR_CFG_FP_EN                      DEF_DISABLED
N                                                                /*   DEF_DISABLED     Floating point functions DISABLED */
N                                                                /*   DEF_ENABLED      Floating point functions ENABLED  */
N#endif
N
N                                                                /* Configure floating point feature(s)' number of ...   */
N                                                                /* ... significant digits (see Note #2).                */
N#ifndef  LIB_STR_CFG_FP_MAX_NBR_DIG_SIG
N#define  LIB_STR_CFG_FP_MAX_NBR_DIG_SIG         LIB_STR_FP_MAX_NBR_DIG_SIG_DFLT
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                               DEFINES
N*********************************************************************************************************
N*/
N
N#define  STR_CR_LF                     "\r\n"
N#define  STR_LF_CR                     "\n\r"
N#define  STR_NEW_LINE                   STR_CR_LF
N#define  STR_PARENT_PATH               ".."
N
N#define  STR_CR_LF_LEN                 (sizeof(STR_CR_LF)       - 1)
N#define  STR_LF_CR_LEN                 (sizeof(STR_LF_CR)       - 1)
N#define  STR_NEW_LINE_LEN              (sizeof(STR_NEW_LINE)    - 1)
N#define  STR_PARENT_PATH_LEN           (sizeof(STR_PARENT_PATH) - 1)
N
N
N/*
N*********************************************************************************************************
N*                                             DATA TYPES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                          GLOBAL VARIABLES
N*********************************************************************************************************
N*/
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                              MACRO'S
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                      STANDARD LIBRARY MACRO'S
N*
N* Note(s) : (1) NO compiler-supplied standard library functions SHOULD be used.
N*
N*               #### The reference to standard memory functions SHOULD be removed once all custom library
N*               functions are implemented WITHOUT reference to ANY standard library function(s).
N*
N*               See also 'INCLUDE FILES  Note #3'.
N*********************************************************************************************************
N*/
N
N                                                                /* See Note #1.                                         */
N#define  Str_FmtPrint                   snprintf
N#define  Str_FmtScan                    sscanf
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         FUNCTION PROTOTYPES
N*********************************************************************************************************
N*/
N
N                                                                /* ------------------ STR LEN  FNCTS ------------------ */
NCPU_SIZE_T   Str_Len            (const  CPU_CHAR      *pstr);
N
NCPU_SIZE_T   Str_Len_N          (const  CPU_CHAR      *pstr,
N                                        CPU_SIZE_T     len_max);
N
N
N                                                                       /* ------------------ STR COPY FNCTS ------------------ */
NCPU_CHAR    *Str_Copy           (       CPU_CHAR      *pstr_dest,
N                                 const  CPU_CHAR      *pstr_src);
N
NCPU_CHAR    *Str_Copy_N         (       CPU_CHAR      *pstr_dest,
N                                 const  CPU_CHAR      *pstr_src,
N                                        CPU_SIZE_T     len_max);
N
N
NCPU_CHAR    *Str_Cat            (       CPU_CHAR      *pstr_dest,
N                                 const  CPU_CHAR      *pstr_cat);
N
NCPU_CHAR    *Str_Cat_N          (       CPU_CHAR      *pstr_dest,
N                                 const  CPU_CHAR      *pstr_cat,
N                                        CPU_SIZE_T     len_max);
N
N
N                                                                       /* ------------------ STR CMP  FNCTS ------------------ */
NCPU_INT16S   Str_Cmp            (const  CPU_CHAR      *p1_str,
N                                 const  CPU_CHAR      *p2_str);
N
NCPU_INT16S   Str_Cmp_N          (const  CPU_CHAR      *p1_str,
N                                 const  CPU_CHAR      *p2_str,
N                                        CPU_SIZE_T     len_max);
N
NCPU_INT16S   Str_CmpIgnoreCase  (const  CPU_CHAR      *p1_str,
N                                 const  CPU_CHAR      *p2_str);
N
NCPU_INT16S   Str_CmpIgnoreCase_N(const  CPU_CHAR      *p1_str,
N                                 const  CPU_CHAR      *p2_str,
N                                        CPU_SIZE_T     len_max);
N
N
N                                                                       /* ------------------ STR SRCH FNCTS ------------------ */
NCPU_CHAR    *Str_Char           (const  CPU_CHAR      *pstr,
N                                        CPU_CHAR       srch_char);
N
NCPU_CHAR    *Str_Char_N         (const  CPU_CHAR      *pstr,
N                                        CPU_SIZE_T     len_max,
N                                        CPU_CHAR       srch_char);
N
NCPU_CHAR    *Str_Char_Last      (const  CPU_CHAR      *pstr,
N                                        CPU_CHAR       srch_char);
N
NCPU_CHAR    *Str_Char_Last_N    (const  CPU_CHAR      *pstr,
N                                        CPU_SIZE_T     len_max,
N                                        CPU_CHAR       srch_char);
N
NCPU_CHAR    *Str_Char_Replace   (       CPU_CHAR      *pstr,
N                                        CPU_CHAR       char_srch,
N                                        CPU_CHAR       char_replace);
N
NCPU_CHAR    *Str_Char_Replace_N (       CPU_CHAR      *pstr,
N                                        CPU_CHAR       char_srch,
N                                        CPU_CHAR       char_replace,
N                                        CPU_SIZE_T     len_max);
N
NCPU_CHAR    *Str_Str            (const  CPU_CHAR      *pstr,
N                                 const  CPU_CHAR      *pstr_srch);
N
NCPU_CHAR    *Str_Str_N          (const  CPU_CHAR      *pstr,
N                                 const  CPU_CHAR      *pstr_srch,
N                                        CPU_SIZE_T     len_max);
N
N
N/*$PAGE*/
N                                                                       /* ------------------ STR FMT  FNCTS ------------------ */
NCPU_CHAR    *Str_FmtNbr_Int32U  (       CPU_INT32U     nbr,
N                                        CPU_INT08U     nbr_dig,
N                                        CPU_INT08U     nbr_base,
N                                        CPU_CHAR       lead_char,
N                                        CPU_BOOLEAN    lower_case,
N                                        CPU_BOOLEAN    nul,
N                                        CPU_CHAR      *pstr);
N
NCPU_CHAR    *Str_FmtNbr_Int32S  (       CPU_INT32S     nbr,
N                                        CPU_INT08U     nbr_dig,
N                                        CPU_INT08U     nbr_base,
N                                        CPU_CHAR       lead_char,
N                                        CPU_BOOLEAN    lower_case,
N                                        CPU_BOOLEAN    nul,
N                                        CPU_CHAR      *pstr);
N
N#if (LIB_STR_CFG_FP_EN == DEF_ENABLED)
X#if (0u == 1u)
SCPU_CHAR    *Str_FmtNbr_32      (       CPU_FP32       nbr,
S                                        CPU_INT08U     nbr_dig,
S                                        CPU_INT08U     nbr_dp,
S                                        CPU_CHAR       lead_char,
S                                        CPU_BOOLEAN    nul,
S                                        CPU_CHAR      *pstr);
N#endif
N
N
N                                                                       /* ----------------- STR PARSE FNCTS ------------------ */
NCPU_INT32U   Str_ParseNbr_Int32U(const  CPU_CHAR      *pstr,
N                                        CPU_CHAR     **pstr_next,
N                                        CPU_INT08U     nbr_base);
N
NCPU_INT32S   Str_ParseNbr_Int32S(const  CPU_CHAR      *pstr,
N                                        CPU_CHAR     **pstr_next,
N                                        CPU_INT08U     nbr_base);
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N#ifndef  LIB_STR_CFG_FP_EN
S#error  "LIB_STR_CFG_FP_EN                     not #define'd in 'lib_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
S#elif  ((LIB_STR_CFG_FP_EN != DEF_DISABLED) && \
S        (LIB_STR_CFG_FP_EN != DEF_ENABLED ))
X#elif  ((0u != 0u) &&         (0u != 1u ))
S#error  "LIB_STR_CFG_FP_EN               illegally #define'd in 'lib_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
S
S#elif   (LIB_STR_CFG_FP_EN == DEF_ENABLED)
X#elif   (0u == 1u)
S
S#ifndef  LIB_STR_CFG_FP_MAX_NBR_DIG_SIG
S#error  "LIB_STR_CFG_FP_MAX_NBR_DIG_SIG        not #define'd in 'lib_cfg.h'          "
S#error  "                                [MUST be  >= LIB_STR_FP_MAX_NBR_DIG_SIG_MIN]"
S#error  "                                [     &&  <= LIB_STR_FP_MAX_NBR_DIG_SIG_MAX]"
S
S#elif   (DEF_CHK_VAL(LIB_STR_CFG_FP_MAX_NBR_DIG_SIG,          \
S                     LIB_STR_FP_MAX_NBR_DIG_SIG_MIN,          \
S                     LIB_STR_FP_MAX_NBR_DIG_SIG_MAX) != DEF_OK)
X#elif   (DEF_CHK_VAL(LIB_STR_CFG_FP_MAX_NBR_DIG_SIG,                               LIB_STR_FP_MAX_NBR_DIG_SIG_MIN,                               LIB_STR_FP_MAX_NBR_DIG_SIG_MAX) != DEF_OK)
S#error  "LIB_STR_CFG_FP_MAX_NBR_DIG_SIG  illegally #define'd in 'lib_cfg.h'          "
S#error  "                                [MUST be  >= LIB_STR_FP_MAX_NBR_DIG_SIG_MIN]"
S#error  "                                [     &&  <= LIB_STR_FP_MAX_NBR_DIG_SIG_MAX]"
S#endif
S
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*
N* Note(s) : (1) See 'lib_str.h  MODULE'.
N*********************************************************************************************************
N*/
N
N#endif                                                          /* End of lib str module include.                       */
N
L 111 "..\..\uCOS-III\uC-CPU\cpu_core.h" 2
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          CPU CONFIGURATION
N*
N* Note(s) : (1) The following pre-processor directives correctly configure CPU parameters.  DO NOT MODIFY.
N*
N*           (2) CPU timestamp timer feature is required for :
N*
N*               (a) CPU timestamps
N*               (b) CPU interrupts disabled time measurement
N*
N*               See also 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
N*                      & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1'.
N*********************************************************************************************************
N*/
N
N#ifdef   CPU_CFG_TS_EN
S#undef   CPU_CFG_TS_EN
N#endif
N
N
N#if    ((CPU_CFG_TS_32_EN == DEF_ENABLED) || \
N        (CPU_CFG_TS_64_EN == DEF_ENABLED))
X#if    ((1u == 1u) ||         (0u == 1u))
N#define  CPU_CFG_TS_EN                          DEF_ENABLED
N#else
S#define  CPU_CFG_TS_EN                          DEF_DISABLED
N#endif
N
N#if    ((CPU_CFG_TS_EN == DEF_ENABLED) || \
N(defined(CPU_CFG_INT_DIS_MEAS_EN)))
X#if    ((1u == 1u) || (0L))
N#define  CPU_CFG_TS_TMR_EN                      DEF_ENABLED
N#else
S#define  CPU_CFG_TS_TMR_EN                      DEF_DISABLED
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                               DEFINES
N*********************************************************************************************************
N*/
N
N#define  CPU_TIME_MEAS_NBR_MIN                             1u
N#define  CPU_TIME_MEAS_NBR_MAX                           128u
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                             DATA TYPES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                           CPU ERROR CODES
N*********************************************************************************************************
N*/
N
Ntypedef enum cpu_err {
N
N    CPU_ERR_NONE                            =         0u,
N    CPU_ERR_NULL_PTR                        =        10u,
N
N    CPU_ERR_NAME_SIZE                       =      1000u,
N
N    CPU_ERR_TS_FREQ_INVALID                 =      2000u
N
N} CPU_ERR;
N
N
N/*
N*********************************************************************************************************
N*                                      CPU TIMESTAMP DATA TYPES
N*
N* Note(s) : (1) CPU timestamp timer data type defined to the binary-multiple of 8-bit octets as configured
N*               by 'CPU_CFG_TS_TMR_SIZE' (see 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #2').
N*********************************************************************************************************
N*/
N
Ntypedef  CPU_INT32U  CPU_TS32;
Ntypedef  CPU_INT64U  CPU_TS64;
N
Ntypedef  CPU_TS32    CPU_TS;                                    /* Req'd for backwards-compatibility.                   */
N
N
N#if     (CPU_CFG_TS_TMR_EN   == DEF_ENABLED)                    /* CPU ts tmr defined to cfg'd word size (see Note #1). */
X#if     (1u   == 1u)
N#if     (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_08)
X#if     (4 == 1)
Stypedef  CPU_INT08U  CPU_TS_TMR;
S#elif   (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_16)
X#elif   (4 == 2)
Stypedef  CPU_INT16U  CPU_TS_TMR;
S#elif   (CPU_CFG_TS_TMR_SIZE == CPU_WORD_SIZE_64)
X#elif   (4 == 8)
Stypedef  CPU_INT64U  CPU_TS_TMR;
N#else                                                           /* CPU ts tmr dflt size = 32-bits.                      */
Ntypedef  CPU_INT32U  CPU_TS_TMR;
N#endif
N#endif
N
N
N/*
N*********************************************************************************************************
N*                               CPU TIMESTAMP TIMER FREQUENCY DATA TYPE
N*********************************************************************************************************
N*/
N
Ntypedef  CPU_INT32U  CPU_TS_TMR_FREQ;
N
N
N/*
N*********************************************************************************************************
N*                                          GLOBAL VARIABLES
N*********************************************************************************************************
N*/
N
N#if    (CPU_CFG_NAME_EN   == DEF_ENABLED)
X#if    (1u   == 1u)
NCPU_CORE_EXT  CPU_CHAR         CPU_Name[CPU_CFG_NAME_SIZE];     /* CPU host name.                                       */
Xextern  CPU_CHAR         CPU_Name[16];
N#endif
N
N
N#if ((CPU_CFG_TS_32_EN    == DEF_ENABLED)  && \
N     (CPU_CFG_TS_TMR_SIZE <  CPU_WORD_SIZE_32))
X#if ((1u    == 1u)  &&      (4 <  4))
SCPU_CORE_EXT  CPU_TS32         CPU_TS_32_Accum;                 /* 32-bit accum'd ts  (in ts tmr cnts).                 */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_TS_32_TmrPrev;               /* 32-bit ts prev tmr (in ts tmr cnts).                 */
N#endif
N
N#if ((CPU_CFG_TS_64_EN    == DEF_ENABLED)  && \
N     (CPU_CFG_TS_TMR_SIZE <  CPU_WORD_SIZE_64))
X#if ((0u    == 1u)  &&      (4 <  8))
SCPU_CORE_EXT  CPU_TS64         CPU_TS_64_Accum;                 /* 64-bit accum'd ts  (in ts tmr cnts).                 */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_TS_64_TmrPrev;               /* 64-bit ts prev tmr (in ts tmr cnts).                 */
N#endif
N
N#if  (CPU_CFG_TS_TMR_EN   == DEF_ENABLED)
X#if  (1u   == 1u)
NCPU_CORE_EXT  CPU_TS_TMR_FREQ  CPU_TS_TmrFreq_Hz;               /* CPU ts tmr freq (in Hz).                             */
Xextern  CPU_TS_TMR_FREQ  CPU_TS_TmrFreq_Hz;
N#endif
N
N
N#ifdef  CPU_CFG_INT_DIS_MEAS_EN
SCPU_CORE_EXT  CPU_INT16U       CPU_IntDisMeasCtr;               /* Nbr tot    ints dis'd ctr.                           */
SCPU_CORE_EXT  CPU_INT16U       CPU_IntDisNestCtr;               /* Nbr nested ints dis'd ctr.                           */
S                                                                /* Ints dis'd time (in ts tmr cnts) : ...               */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasStart_cnts;        /* ...  start time.                                     */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasStop_cnts;         /* ...  stop  time.                                     */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasOvrhd_cnts;        /* ...        time meas ovrhd.                          */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasMaxCur_cnts;       /* ...     resetable max time dis'd.                    */
SCPU_CORE_EXT  CPU_TS_TMR       CPU_IntDisMeasMax_cnts;          /* ... non-resetable max time dis'd.                    */
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                               MACRO'S
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                         CPU_SW_EXCEPTION()
N*
N* Description : Trap unrecoverable software exception.
N*
N* Argument(s) : err_rtn_val     Error type &/or value of the calling function to return (see Note #2b).
N*
N* Return(s)   : none.
N*
N* Caller(s)   : various.
N*
N* Note(s)     : (1) CPU_SW_EXCEPTION() deadlocks the current code execution -- whether multi-tasked/
N*                   -processed/-threaded or single-threaded -- when the current code execution cannot
N*                   gracefully recover or report a fault or exception condition.
N*
N*                   Example CPU_SW_EXCEPTION() call :
N*
N*                       void  Fnct (CPU_ERR  *p_err)
N*                       {
N*                           :
N*
N*                           if (p_err == (CPU_ERR *)0) {        If 'p_err' NULL, cannot return error ...
N*                               CPU_SW_EXCEPTION(;);            ... so trap invalid argument exception.
N*                           }
N*
N*                           :
N*                       }
N*
N*                   See also 'cpu_core.c  CPU_SW_Exception()  Note #1'.
N*
N*               (2) (a) CPU_SW_EXCEPTION()  MAY be developer-implemented to output &/or handle any error or
N*                       exception conditions; but since CPU_SW_EXCEPTION() is intended to trap unrecoverable
N*                       software  conditions, it is recommended that developer-implemented versions prevent
N*                       execution of any code following calls to CPU_SW_EXCEPTION() by deadlocking the code
N*                       (see Note #1).
N*
N*                           Example CPU_SW_EXCEPTION() :
N*
N*                               #define  CPU_SW_EXCEPTION(err_rtn_val)      do {                         \
N*                                                                               Log(__FILE__, __LINE__); \
N*                                                                               CPU_SW_Exception();      \
N*                                                                           } while (0)
X
N*
N*                   (b) (1) However, if execution of code following calls to CPU_SW_EXCEPTION() is required
N*                           (e.g. for automated testing); it is recommended that the last statement in
N*                           developer-implemented versions be to return from the current function to prevent
N*                           possible software exception(s) in the current function from triggering CPU &/or
N*                           hardware exception(s).
N*
N*                           Example CPU_SW_EXCEPTION() :
N*
N*                               #define  CPU_SW_EXCEPTION(err_rtn_val)      do {                         \
N*                                                                               Log(__FILE__, __LINE__); \
N*                                                                               return  err_rtn_val;     \
N*                                                                           } while (0)
X
N*
N*                           (A) Note that 'err_rtn_val' in the return statement MUST NOT be enclosed in
N*                               parentheses.  This allows CPU_SW_EXCEPTION() to return from functions that
N*                               return 'void', i.e. NO return type or value (see also Note #2b2A).
N*$PAGE*
N*                       (2) In order for CPU_SW_EXCEPTION() to return from functions with various return
N*                           types/values, each caller function MUST pass an appropriate error return type
N*                           & value to CPU_SW_EXCEPTION().
N*
N*                           (A) Note that CPU_SW_EXCEPTION()  MUST NOT be passed any return type or value
N*                               for functions that return 'void', i.e. NO return type or value; but SHOULD
N*                               instead be passed a single semicolon.  This prevents possible compiler
N*                               warnings that CPU_SW_EXCEPTION() is passed too few arguments.  However,
N*                               the compiler may warn that CPU_SW_EXCEPTION() does NOT prevent creating
N*                               null statements on lines with NO other code statements.
N*
N*                           Example CPU_SW_EXCEPTION() calls :
N*
N*                               void  Fnct (CPU_ERR  *p_err)
N*                               {
N*                                   :
N*
N*                                   if (p_err == (CPU_ERR *)0) {
N*                                       CPU_SW_EXCEPTION(;);            Exception macro returns NO value
N*                                   }                                       (see Note #2b2A)
N*
N*                                   :
N*                               }
N*
N*                               CPU_BOOLEAN  Fnct (CPU_ERR  *p_err)
N*                               {
N*                                   :
N*
N*                                   if (p_err == (CPU_ERR *)0) {
N*                                       CPU_SW_EXCEPTION(DEF_FAIL);     Exception macro returns 'DEF_FAIL'
N*                                   }
N*
N*                                   :
N*                               }
N*
N*                               OBJ  *Fnct (CPU_ERR  *p_err)
N*                               {
N*                                   :
N*
N*                                   if (p_err == (CPU_ERR *)0) {
N*                                       CPU_SW_EXCEPTION((OBJ *)0);     Exception macro returns NULL 'OBJ *'
N*                                   }
N*
N*                                   :
N*                               }
N*
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_SW_EXCEPTION                                                       /* See Note #2.                         */
N#define  CPU_SW_EXCEPTION(err_rtn_val)              do {                    \
N                                                        CPU_SW_Exception(); \
N                                                    } while (0)
X#define  CPU_SW_EXCEPTION(err_rtn_val)              do {                                                                            CPU_SW_Exception();                                                     } while (0)
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                           CPU_VAL_UNUSED()
N*
N* Description :
N*
N* Argument(s) : none.
N*
N* Return(s)   : none.
N*
N* Caller(s)   : #### various.
N*
N* Note(s)     : none.
N*********************************************************************************************************
N*/
N
N
N#define  CPU_VAL_UNUSED(val)        ((void)&(val));
N
N
N#define  CPU_VAL_IGNORED(val)       CPU_VAL_UNUSED(val)
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                          CPU_TYPE_CREATE()
N*
N* Description : Creates a generic type value.
N*
N* Argument(s) : char_1      1st ASCII character to create generic type value.
N*
N*               char_2      2nd ASCII character to create generic type value.
N*
N*               char_3      3rd ASCII character to create generic type value.
N*
N*               char_4      4th ASCII character to create generic type value.
N*
N* Return(s)   : 32-bit generic type value.
N*
N* Caller(s)   : various.
N*
N* Note(s)     : (1) (a) Generic type values should be #define'd with large, non-trivial values to trap
N*                       & discard invalid/corrupted objects based on type value.
N*
N*                       In other words, by assigning large, non-trivial values to valid objects' type
N*                       fields; the likelihood that an object with an unassigned &/or corrupted type
N*                       field will contain a value is highly improbable & therefore the object itself
N*                       will be trapped as invalid.
N*
N*                   (b) (1) CPU_TYPE_CREATE()  creates a 32-bit type value from four values.
N*
N*                       (2) Ideally, generic type values SHOULD be created from 'CPU_CHAR' characters to
N*                           represent ASCII string abbreviations of the specific object types.  Memory
N*                           displays of object type values will display the specific object types with
N*                           their chosen ASCII names.
N*
N*                           Examples :
N*
N*                               #define  FILE_TYPE  CPU_TYPE_CREATE('F', 'I', 'L', 'E')
N*                               #define  BUF_TYPE   CPU_TYPE_CREATE('B', 'U', 'F', ' ')
N*********************************************************************************************************
N*/
N
N#if     (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
X#if     (2u == 1u)
S#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))
X#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))
S
N#else
N
N#if    ((CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_64) || \
N        (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_32))
X#if    ((4   == 8) ||         (4   == 4))
N#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (0u * DEF_OCTET_NBR_BITS)) | \
N                                                                 ((CPU_INT32U)((CPU_INT08U)(char_2)) << (1u * DEF_OCTET_NBR_BITS)) | \
N                                                                 ((CPU_INT32U)((CPU_INT08U)(char_3)) << (2u * DEF_OCTET_NBR_BITS)) | \
N                                                                 ((CPU_INT32U)((CPU_INT08U)(char_4)) << (3u * DEF_OCTET_NBR_BITS)))
X#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (0u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (1u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (2u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (3u * DEF_OCTET_NBR_BITS)))
N
N
N#elif   (CPU_CFG_DATA_SIZE   == CPU_WORD_SIZE_16)
S#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (2u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_2)) << (3u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_3)) << (0u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_4)) << (1u * DEF_OCTET_NBR_BITS)))
X#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (2u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (3u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (0u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (1u * DEF_OCTET_NBR_BITS)))
S
S#else                                                           /* Dflt CPU_WORD_SIZE_08.                               */
S#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) | \
S                                                                 ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))
X#define  CPU_TYPE_CREATE(char_1, char_2, char_3, char_4)        (((CPU_INT32U)((CPU_INT08U)(char_1)) << (3u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_2)) << (2u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_3)) << (1u * DEF_OCTET_NBR_BITS)) |                                                                  ((CPU_INT32U)((CPU_INT08U)(char_4)) << (0u * DEF_OCTET_NBR_BITS)))
N#endif
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         FUNCTION PROTOTYPES
N*
N* Note(s) : (1) CPU interrupts disabled time measurement functions prototyped/defined only if
N*               CPU_CFG_INT_DIS_MEAS_EN  #define'd in 'cpu_cfg.h'.
N*
N*           (2) (a) CPU_CntLeadZeros()  defined in :
N*
N*                   (1) 'cpu_a.asm',  if CPU_CFG_LEAD_ZEROS_ASM_PRESENT       #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable assembly-optimized function(s)
N*
N*                   (2) 'cpu_core.c', if CPU_CFG_LEAD_ZEROS_ASM_PRESENT   NOT #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable C-source-optimized function(s)
N*
N*               (b) CPU_CntTrailZeros() defined in :
N*
N*                   (1) 'cpu_a.asm',  if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT      #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable assembly-optimized function(s)
N*
N*                   (2) 'cpu_core.c', if CPU_CFG_TRAIL_ZEROS_ASM_PRESENT  NOT #define'd in 'cpu.h'/
N*                                         'cpu_cfg.h' to enable C-source-optimized function(s)
N*********************************************************************************************************
N*/
N
Nvoid             CPU_Init                 (void);
N
Nvoid             CPU_SW_Exception         (void);
N
N
N
N#if (CPU_CFG_NAME_EN == DEF_ENABLED)                                    /* -------------- CPU NAME FNCTS -------------- */
X#if (1u == 1u)
Nvoid             CPU_NameClr              (void);
N
Nvoid             CPU_NameGet              (       CPU_CHAR  *p_name,
N                                                  CPU_ERR   *p_err);
N
Nvoid             CPU_NameSet              (const  CPU_CHAR  *p_name,
N                                                  CPU_ERR   *p_err);
N#endif
N
N
N
N                                                                        /* --------------- CPU TS FNCTS --------------- */
N#if (CPU_CFG_TS_32_EN == DEF_ENABLED)
X#if (1u == 1u)
NCPU_TS32         CPU_TS_Get32             (void);
N#endif
N
N#if (CPU_CFG_TS_64_EN == DEF_ENABLED)
X#if (0u == 1u)
SCPU_TS64         CPU_TS_Get64             (void);
N#endif
N
N#if (CPU_CFG_TS_EN    == DEF_ENABLED)
X#if (1u    == 1u)
Nvoid             CPU_TS_Update            (void);
N#endif
N
N
N#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)                                  /* ------------- CPU TS TMR FNCTS ------------- */
X#if (1u == 1u)
NCPU_TS_TMR_FREQ  CPU_TS_TmrFreqGet        (CPU_ERR          *p_err);
N
Nvoid             CPU_TS_TmrFreqSet        (CPU_TS_TMR_FREQ   freq_hz);
N#endif
N
N
N
N#ifdef  CPU_CFG_INT_DIS_MEAS_EN                                         /* -------- CPU INT DIS TIME MEAS FNCTS ------- */
S                                                                        /* See Note #1.                                 */
SCPU_TS_TMR       CPU_IntDisMeasMaxCurReset(void);
S
SCPU_TS_TMR       CPU_IntDisMeasMaxCurGet  (void);
S
SCPU_TS_TMR       CPU_IntDisMeasMaxGet     (void);
S
S
Svoid             CPU_IntDisMeasStart      (void);
S
Svoid             CPU_IntDisMeasStop       (void);
N#endif
N
N
N
N                                                                        /* ----------- CPU CNT ZEROS FNCTS ------------ */
NCPU_DATA         CPU_CntLeadZeros         (CPU_DATA    val);
N
N#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_08)
X#if     (8 >= 1)
NCPU_DATA         CPU_CntLeadZeros08       (CPU_INT08U  val);
N#endif
N#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_16)
X#if     (8 >= 2)
NCPU_DATA         CPU_CntLeadZeros16       (CPU_INT16U  val);
N#endif
N#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_32)
X#if     (8 >= 4)
NCPU_DATA         CPU_CntLeadZeros32       (CPU_INT32U  val);
N#endif
N#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_64)
X#if     (8 >= 8)
NCPU_DATA         CPU_CntLeadZeros64       (CPU_INT64U  val);
N#endif
N
N
NCPU_DATA         CPU_CntTrailZeros        (CPU_DATA    val);
N
N#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_08)
X#if     (8 >= 1)
NCPU_DATA         CPU_CntTrailZeros08      (CPU_INT08U  val);
N#endif
N#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_16)
X#if     (8 >= 2)
NCPU_DATA         CPU_CntTrailZeros16      (CPU_INT16U  val);
N#endif
N#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_32)
X#if     (8 >= 4)
NCPU_DATA         CPU_CntTrailZeros32      (CPU_INT32U  val);
N#endif
N#if     (CPU_CFG_DATA_SIZE_MAX >= CPU_WORD_SIZE_64)
X#if     (8 >= 8)
NCPU_DATA         CPU_CntTrailZeros64      (CPU_INT64U  val);
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         FUNCTION PROTOTYPES
N*                                      DEFINED IN PRODUCT'S BSP
N*********************************************************************************************************
N*/
N
N/*
N*********************************************************************************************************
N*                                          CPU_TS_TmrInit()
N*
N* Description : Initialize & start CPU timestamp timer.
N*
N* Argument(s) : none.
N*
N* Return(s)   : none.
N*
N* Caller(s)   : CPU_TS_Init().
N*
N*               This function is an INTERNAL CPU module function & MUST be implemented by application/
N*               BSP function(s) [see Note #1] but MUST NOT be called by application function(s).
N*
N* Note(s)     : (1) CPU_TS_TmrInit() is an application/BSP function that MUST be defined by the developer
N*                   if either of the following CPU features is enabled :
N*
N*                   (a) CPU timestamps
N*                   (b) CPU interrupts disabled time measurements
N*
N*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
N*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
N*
N*               (2) (a) Timer count values MUST be returned via word-size-configurable 'CPU_TS_TMR'
N*                       data type.
N*
N*                       (1) If timer has more bits, truncate timer values' higher-order bits greater
N*                           than the configured 'CPU_TS_TMR' timestamp timer data type word size.
N*
N*                       (2) Since the timer MUST NOT have less bits than the configured 'CPU_TS_TMR'
N*                           timestamp timer data type word size; 'CPU_CFG_TS_TMR_SIZE' MUST be
N*                           configured so that ALL bits in 'CPU_TS_TMR' data type are significant.
N*
N*                           In other words, if timer size is not a binary-multiple of 8-bit octets
N*                           (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple
N*                           octet word size SHOULD be configured (e.g. to 16-bits).  However, the
N*                           minimum supported word size for CPU timestamp timers is 8-bits.
N*
N*                       See also 'cpu_cfg.h   CPU TIMESTAMP CONFIGURATION  Note #2'
N*                              & 'cpu_core.h  CPU TIMESTAMP DATA TYPES     Note #1'.
N*
N*                   (b) Timer SHOULD be an 'up'  counter whose values increase with each time count.
N*
N*                   (c) When applicable, timer period SHOULD be less than the typical measured time
N*                       but MUST be less than the maximum measured time; otherwise, timer resolution
N*                       inadequate to measure desired times.
N*
N*                   See also 'CPU_TS_TmrRd()  Note #2'.
N*********************************************************************************************************
N*/
N
N#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
X#if (1u == 1u)
Nvoid  CPU_TS_TmrInit(void);
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                           CPU_TS_TmrRd()
N*
N* Description : Get current CPU timestamp timer count value.
N*
N* Argument(s) : none.
N*
N* Return(s)   : Timestamp timer count (see Notes #2a & #2b).
N*
N* Caller(s)   : CPU_TS_Init(),
N*               CPU_TS_Get32(),
N*               CPU_TS_Get64(),
N*               CPU_IntDisMeasStart(),
N*               CPU_IntDisMeasStop().
N*
N*               This function is an INTERNAL CPU module function & MUST be implemented by application/
N*               BSP function(s) [see Note #1] but SHOULD NOT be called by application function(s).
N*
N* Note(s)     : (1) CPU_TS_TmrRd() is an application/BSP function that MUST be defined by the developer
N*                   if either of the following CPU features is enabled :
N*
N*                   (a) CPU timestamps
N*                   (b) CPU interrupts disabled time measurements
N*
N*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
N*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
N*
N*               (2) (a) Timer count values MUST be returned via word-size-configurable 'CPU_TS_TMR'
N*                       data type.
N*
N*                       (1) If timer has more bits, truncate timer values' higher-order bits greater
N*                           than the configured 'CPU_TS_TMR' timestamp timer data type word size.
N*
N*                       (2) Since the timer MUST NOT have less bits than the configured 'CPU_TS_TMR'
N*                           timestamp timer data type word size; 'CPU_CFG_TS_TMR_SIZE' MUST be
N*                           configured so that ALL bits in 'CPU_TS_TMR' data type are significant.
N*
N*                           In other words, if timer size is not a binary-multiple of 8-bit octets
N*                           (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple
N*                           octet word size SHOULD be configured (e.g. to 16-bits).  However, the
N*                           minimum supported word size for CPU timestamp timers is 8-bits.
N*
N*                       See also 'cpu_cfg.h   CPU TIMESTAMP CONFIGURATION  Note #2'
N*                              & 'cpu_core.h  CPU TIMESTAMP DATA TYPES     Note #1'.
N*
N*                   (b) Timer SHOULD be an 'up'  counter whose values increase with each time count.
N*
N*                       (1) If timer is a 'down' counter whose values decrease with each time count,
N*                           then the returned timer value MUST be ones-complemented.
N*
N*                   (c) (1) When applicable, the amount of time measured by CPU timestamps is
N*                           calculated by either of the following equations :
N*
N*                           (A) Time measured  =  Number timer counts  *  Timer period
N*
N*                                   where
N*
N*                                       Number timer counts     Number of timer counts measured
N*                                       Timer period            Timer's period in some units of
N*                                                                   (fractional) seconds
N*                                       Time measured           Amount of time measured, in same
N*                                                                   units of (fractional) seconds
N*                                                                   as the Timer period
N*
N*                                                  Number timer counts
N*                           (B) Time measured  =  ---------------------
N*                                                    Timer frequency
N*
N*                                   where
N*
N*                                       Number timer counts     Number of timer counts measured
N*                                       Timer frequency         Timer's frequency in some units
N*                                                                   of counts per second
N*                                       Time measured           Amount of time measured, in seconds
N*
N*                       (2) Timer period SHOULD be less than the typical measured time but MUST be less
N*                           than the maximum measured time; otherwise, timer resolution inadequate to
N*                           measure desired times.
N*********************************************************************************************************
N*/
N
N#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
X#if (1u == 1u)
NCPU_TS_TMR  CPU_TS_TmrRd(void);
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                         CPU_TSxx_to_uSec()
N*
N* Description : Convert a 32-/64-bit CPU timestamp from timer counts to microseconds.
N*
N* Argument(s) : ts_cnts   CPU timestamp (in timestamp timer counts [see Note #2aA]).
N*
N* Return(s)   : Converted CPU timestamp (in microseconds           [see Note #2aD]).
N*
N* Caller(s)   : Application.
N*
N*               This function is an (optional) CPU module application programming interface (API)
N*               function which MAY be implemented by application/BSP function(s) [see Note #1] &
N*               MAY be called by application function(s).
N*
N* Note(s)     : (1) CPU_TS32_to_uSec()/CPU_TS64_to_uSec() are application/BSP functions that MAY be
N*                   optionally defined by the developer when either of the following CPU features is
N*                   enabled :
N*
N*                   (a) CPU timestamps
N*                   (b) CPU interrupts disabled time measurements
N*
N*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
N*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
N*
N*               (2) (a) The amount of time measured by CPU timestamps is calculated by either of
N*                       the following equations :
N*
N*                                                                        10^6 microseconds
N*                       (1) Time measured  =   Number timer counts   *  -------------------  *  Timer period
N*                                                                            1 second
N*
N*                                              Number timer counts       10^6 microseconds
N*                       (2) Time measured  =  ---------------------  *  -------------------
N*                                                Timer frequency             1 second
N*
N*                               where
N*
N*                                   (A) Number timer counts     Number of timer counts measured
N*                                   (B) Timer frequency         Timer's frequency in some units
N*                                                                   of counts per second
N*                                   (C) Timer period            Timer's period in some units of
N*                                                                   (fractional)  seconds
N*                                   (D) Time measured           Amount of time measured,
N*                                                                   in microseconds
N*
N*                   (b) Timer period SHOULD be less than the typical measured time but MUST be less
N*                       than the maximum measured time; otherwise, timer resolution inadequate to
N*                       measure desired times.
N*
N*                   (c) Specific implementations may convert any number of CPU_TS32 or CPU_TS64 bits
N*                       -- up to 32 or 64, respectively -- into microseconds.
N*********************************************************************************************************
N*/
N
N#if (CPU_CFG_TS_32_EN == DEF_ENABLED)
X#if (1u == 1u)
NCPU_INT64U  CPU_TS32_to_uSec(CPU_TS32  ts_cnts);
N#endif
N
N#if (CPU_CFG_TS_64_EN == DEF_ENABLED)
X#if (0u == 1u)
SCPU_INT64U  CPU_TS64_to_uSec(CPU_TS64  ts_cnts);
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                        CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_CFG_NAME_EN
S#error  "CPU_CFG_NAME_EN                       not #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_ENABLED ]           "
S#error  "                                [     ||  DEF_DISABLED]           "
S
S#elif  ((CPU_CFG_NAME_EN != DEF_ENABLED ) && \
S        (CPU_CFG_NAME_EN != DEF_DISABLED))
X#elif  ((1u != 1u ) &&         (1u != 0u))
S#error  "CPU_CFG_NAME_EN                 illegally #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_ENABLED ]           "
S#error  "                                [     ||  DEF_DISABLED]           "
S
S
N#elif   (CPU_CFG_NAME_EN == DEF_ENABLED)
X#elif   (1u == 1u)
N
N#ifndef  CPU_CFG_NAME_SIZE
S#error  "CPU_CFG_NAME_SIZE                     not #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  >=   1]                 "
S#error  "                                [     &&  <= 255]                 "
S
S#elif   (DEF_CHK_VAL(CPU_CFG_NAME_SIZE,            \
S                     1,                            \
S                     DEF_INT_08U_MAX_VAL) != DEF_OK)
X#elif   (((((((!(((16) >= 1) && ((1) < 1))) && ((((1) >= 1) && ((16) < 1)) || ((16) < (1)))) ? 0u : 1u) == 0u) || ((((!(((255u) >= 1) && ((16) < 1))) && ((((16) >= 1) && ((255u) < 1)) || ((16) > (255u)))) ? 0u : 1u) == 0u)) ? 0u : 1u) != 1u)
S#error  "CPU_CFG_NAME_SIZE               illegally #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  >=   1]                 "
S#error  "                                [     &&  <= 255]                 "
N#endif
N
N#endif
N
N
N
N
N#ifndef  CPU_CFG_TS_32_EN
S#error  "CPU_CFG_TS_32_EN                      not #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
S#elif  ((CPU_CFG_TS_32_EN != DEF_DISABLED) && \
S        (CPU_CFG_TS_32_EN != DEF_ENABLED ))
X#elif  ((1u != 0u) &&         (1u != 1u ))
S#error  "CPU_CFG_TS_32_EN                illegally #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
N#endif
N
N
N#ifndef  CPU_CFG_TS_64_EN
S#error  "CPU_CFG_TS_64_EN                      not #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
S#elif  ((CPU_CFG_TS_64_EN != DEF_DISABLED) && \
S        (CPU_CFG_TS_64_EN != DEF_ENABLED ))
X#elif  ((0u != 0u) &&         (0u != 1u ))
S#error  "CPU_CFG_TS_64_EN                illegally #define'd in 'cpu_cfg.h'"
S#error  "                                [MUST be  DEF_DISABLED]           "
S#error  "                                [     ||  DEF_ENABLED ]           "
S
N#endif
N
N                                                                /* Correctly configured in 'cpu_core.h'; DO NOT MODIFY. */
N#ifndef  CPU_CFG_TS_EN
S#error  "CPU_CFG_TS_EN                         not #define'd in 'cpu_core.h'"
S#error  "                                [MUST be  DEF_DISABLED]            "
S#error  "                                [     ||  DEF_ENABLED ]            "
S
S#elif  ((CPU_CFG_TS_EN != DEF_DISABLED) && \
S        (CPU_CFG_TS_EN != DEF_ENABLED ))
X#elif  ((1u != 0u) &&         (1u != 1u ))
S#error  "CPU_CFG_TS_EN                   illegally #define'd in 'cpu_core.h'"
S#error  "                                [MUST be  DEF_DISABLED]            "
S#error  "                                [     ||  DEF_ENABLED ]            "
S
N#endif
N
N
N/*$PAGE*/
N                                                                /* Correctly configured in 'cpu_core.h'; DO NOT MODIFY. */
N#ifndef  CPU_CFG_TS_TMR_EN
S#error  "CPU_CFG_TS_TMR_EN                     not #define'd in 'cpu_core.h'"
S#error  "                                [MUST be  DEF_DISABLED]            "
S#error  "                                [     ||  DEF_ENABLED ]            "
S
S#elif  ((CPU_CFG_TS_TMR_EN != DEF_DISABLED) && \
S        (CPU_CFG_TS_TMR_EN != DEF_ENABLED ))
X#elif  ((1u != 0u) &&         (1u != 1u ))
S#error  "CPU_CFG_TS_TMR_EN               illegally #define'd in 'cpu_core.h'"
S#error  "                                [MUST be  DEF_DISABLED]            "
S#error  "                                [     ||  DEF_ENABLED ]            "
S
S
N#elif   (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
X#elif   (1u == 1u)
N
N#ifndef  CPU_CFG_TS_TMR_SIZE
S#error  "CPU_CFG_TS_TMR_SIZE                   not #define'd in 'cpu_cfg.h'       "
S#error  "                                [MUST be  CPU_WORD_SIZE_08   8-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_16  16-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_32  32-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_64  64-bit timer]"
S
S#elif  ((CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_08) && \
S        (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_16) && \
S        (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_32) && \
S        (CPU_CFG_TS_TMR_SIZE != CPU_WORD_SIZE_64))
X#elif  ((4 != 1) &&         (4 != 2) &&         (4 != 4) &&         (4 != 8))
S#error  "CPU_CFG_TS_TMR_SIZE             illegally #define'd in 'cpu_cfg.h'       "
S#error  "                                [MUST be  CPU_WORD_SIZE_08   8-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_16  16-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_32  32-bit timer]"
S#error  "                                [     ||  CPU_WORD_SIZE_64  64-bit timer]"
N#endif
N
N#endif
N
N
N
N#ifndef  CPU_CFG_INT_DIS_MEAS_EN
N#if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */
S#error  "CPU_CFG_INT_DIS_MEAS_EN               not #define'd in 'cpu_cfg.h'"
N#endif
N
N#else
S
S#ifndef  CPU_CFG_INT_DIS_MEAS_OVRHD_NBR
S#error  "CPU_CFG_INT_DIS_MEAS_OVRHD_NBR        not #define'd in 'cpu_cfg.h' "
S#error  "                                [MUST be  >= CPU_TIME_MEAS_NBR_MIN]"
S#error  "                                [     ||  <= CPU_TIME_MEAS_NBR_MAX]"
S
S#elif   (DEF_CHK_VAL(CPU_CFG_INT_DIS_MEAS_OVRHD_NBR, \
S                     CPU_TIME_MEAS_NBR_MIN,          \
S                     CPU_TIME_MEAS_NBR_MAX) != DEF_OK)
X#elif   (DEF_CHK_VAL(CPU_CFG_INT_DIS_MEAS_OVRHD_NBR,                      CPU_TIME_MEAS_NBR_MIN,                               CPU_TIME_MEAS_NBR_MAX) != DEF_OK)
S#error  "CPU_CFG_INT_DIS_MEAS_OVRHD_NBR  illegally #define'd in 'cpu_cfg.h' "
S#error  "                                [MUST be  >= CPU_TIME_MEAS_NBR_MIN]"
S#error  "                                [     ||  <= CPU_TIME_MEAS_NBR_MAX]"
S
S#endif
S
N#endif
N
N
N
N
N#ifndef  CPU_CFG_LEAD_ZEROS_ASM_PRESENT
S#if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */
S#error  "CPU_CFG_LEAD_ZEROS_ASM_PRESENT        not #define'd in 'cpu.h'/'cpu_cfg.h'"
S#endif
N#endif
N
N
N#ifndef  CPU_CFG_TRAIL_ZEROS_ASM_PRESENT
S#if 0                                                           /* Optionally configured in 'cpu_cfg.h'; DO NOT MODIFY. */
S#error  "CPU_CFG_TRAIL_ZEROS_ASM_PRESENT       not #define'd in 'cpu.h'/'cpu_cfg.h'"
S#endif
N#endif
N
N
N/*$PAGE*/
N/*
N*********************************************************************************************************
N*                                    CPU PORT CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N#ifndef  CPU_CFG_ADDR_SIZE
S#error  "CPU_CFG_ADDR_SIZE      not #define'd in 'cpu.h'"
N#endif
N
N#ifndef  CPU_CFG_DATA_SIZE
S#error  "CPU_CFG_DATA_SIZE      not #define'd in 'cpu.h'"
N#endif
N
N#ifndef  CPU_CFG_DATA_SIZE_MAX
S#error  "CPU_CFG_DATA_SIZE_MAX  not #define'd in 'cpu.h'"
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                    LIBRARY CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N                                                                /* See 'cpu_core.h  Note #1a'.                          */
N#if     (LIB_VERSION < 13500u)
X#if     (13700u < 13500u)
S#error  "LIB_VERSION  [SHOULD be >= V1.35.00]"
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                             MODULE END
N*
N* Note(s) : (1) See 'cpu_core.h  MODULE'.
N*********************************************************************************************************
N*/
N
N#endif                                                          /* End of CPU core module include.                      */
N
L 47 "..\..\User\cpu_bsp.c" 2
N
N
N/*
N*********************************************************************************************************
N*                                             REGISTERS
N*********************************************************************************************************
N*/
N
N#define  CPU_REG_DEM_CR                       (*(CPU_REG32 *)0xE000EDFC)
N#define  CPU_REG_DWT_CR                       (*(CPU_REG32 *)0xE0001000)
N#define  CPU_REG_DWT_CYCCNT                   (*(CPU_REG32 *)0xE0001004)
N#define  CPU_REG_DBGMCU_CR                    (*(CPU_REG32 *)0xE0042004)
N
N/*
N*********************************************************************************************************
N*                                            REGISTER BITS
N*********************************************************************************************************
N*/
N
N#define  CPU_DBGMCU_CR_TRACE_IOEN_MASK                   0x10
N#define  CPU_DBGMCU_CR_TRACE_MODE_ASYNC                  0x00
N#define  CPU_DBGMCU_CR_TRACE_MODE_SYNC_01                0x40
N#define  CPU_DBGMCU_CR_TRACE_MODE_SYNC_02                0x80
N#define  CPU_DBGMCU_CR_TRACE_MODE_SYNC_04                0xC0
N#define  CPU_DBGMCU_CR_TRACE_MODE_MASK                   0xC0
N
N#define  CPU_BIT_DEM_CR_TRCENA                    DEF_BIT_24
N
N#define  CPU_BIT_DWT_CR_CYCCNTENA                 DEF_BIT_00
N
N
N/*
N*********************************************************************************************************
N*                                            LOCAL DEFINES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                           LOCAL CONSTANTS
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                          LOCAL DATA TYPES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                            LOCAL TABLES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                       LOCAL GLOBAL VARIABLES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                      LOCAL FUNCTION PROTOTYPES
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                     LOCAL CONFIGURATION ERRORS
N*********************************************************************************************************
N*/
N
N
N/*
N*********************************************************************************************************
N*                                          CPU_TS_TmrInit()
N*
N* Description : Initialize & start CPU timestamp timer.
N*
N* Argument(s) : none.
N*
N* Return(s)   : none.
N*
N* Caller(s)   : CPU_TS_Init().
N*
N*               This function is an INTERNAL CPU module function & MUST be implemented by application/
N*               BSP function(s) [see Note #1] but MUST NOT be called by application function(s).
N*
N* Note(s)     : (1) CPU_TS_TmrInit() is an application/BSP function that MUST be defined by the developer
N*                   if either of the following CPU features is enabled :
N*
N*                   (a) CPU timestamps
N*                   (b) CPU interrupts disabled time measurements
N*
N*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
N*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
N*
N*               (2) (a) Timer count values MUST be returned via word-size-configurable 'CPU_TS_TMR'
N*                       data type.
N*
N*                       (1) If timer has more bits, truncate timer values' higher-order bits greater
N*                           than the configured 'CPU_TS_TMR' timestamp timer data type word size.
N*
N*                       (2) Since the timer MUST NOT have less bits than the configured 'CPU_TS_TMR'
N*                           timestamp timer data type word size; 'CPU_CFG_TS_TMR_SIZE' MUST be
N*                           configured so that ALL bits in 'CPU_TS_TMR' data type are significant.
N*
N*                           In other words, if timer size is not a binary-multiple of 8-bit octets
N*                           (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple
N*                           octet word size SHOULD be configured (e.g. to 16-bits).  However, the
N*                           minimum supported word size for CPU timestamp timers is 8-bits.
N*
N*                       See also 'cpu_cfg.h   CPU TIMESTAMP CONFIGURATION  Note #2'
N*                              & 'cpu_core.h  CPU TIMESTAMP DATA TYPES     Note #1'.
N*
N*                   (b) Timer SHOULD be an 'up'  counter whose values increase with each time count.
N*
N*                   (c) When applicable, timer period SHOULD be less than the typical measured time
N*                       but MUST be less than the maximum measured time; otherwise, timer resolution
N*                       inadequate to measure desired times.
N*
N*                   See also 'CPU_TS_TmrRd()  Note #2'.
N*********************************************************************************************************
N*/
Nextern CPU_INT32U  BSP_CPU_ClkFreq (void);
N#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
X#if (1u == 1u)
Nvoid  CPU_TS_TmrInit (void)
N{
N    CPU_INT32U  fclk_freq;
N
N
N    fclk_freq = BSP_CPU_ClkFreq();
N
N    CPU_REG_DEM_CR     |= (CPU_INT32U)CPU_BIT_DEM_CR_TRCENA;    /* Enable Cortex-M4's DWT CYCCNT reg.                   */
X    (*(CPU_REG32 *)0xE000EDFC)     |= (CPU_INT32U)0x01000000u;
N    CPU_REG_DWT_CYCCNT  = (CPU_INT32U)0u;
X    (*(CPU_REG32 *)0xE0001004)  = (CPU_INT32U)0u;
N    CPU_REG_DWT_CR     |= (CPU_INT32U)CPU_BIT_DWT_CR_CYCCNTENA;
X    (*(CPU_REG32 *)0xE0001000)     |= (CPU_INT32U)0x01u;
N
N    CPU_TS_TmrFreqSet((CPU_TS_TMR_FREQ)fclk_freq);
N}
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                           CPU_TS_TmrRd()
N*
N* Description : Get current CPU timestamp timer count value.
N*
N* Argument(s) : none.
N*
N* Return(s)   : Timestamp timer count (see Notes #2a & #2b).
N*
N* Caller(s)   : CPU_TS_Init(),
N*               CPU_TS_Get32(),
N*               CPU_TS_Get64(),
N*               CPU_IntDisMeasStart(),
N*               CPU_IntDisMeasStop().
N*
N*               This function is an INTERNAL CPU module function & MUST be implemented by application/
N*               BSP function(s) [see Note #1] but SHOULD NOT be called by application function(s).
N*
N* Note(s)     : (1) CPU_TS_TmrRd() is an application/BSP function that MUST be defined by the developer
N*                   if either of the following CPU features is enabled :
N*
N*                   (a) CPU timestamps
N*                   (b) CPU interrupts disabled time measurements
N*
N*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
N*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
N*
N*               (2) (a) Timer count values MUST be returned via word-size-configurable 'CPU_TS_TMR'
N*                       data type.
N*
N*                       (1) If timer has more bits, truncate timer values' higher-order bits greater
N*                           than the configured 'CPU_TS_TMR' timestamp timer data type word size.
N*
N*                       (2) Since the timer MUST NOT have less bits than the configured 'CPU_TS_TMR'
N*                           timestamp timer data type word size; 'CPU_CFG_TS_TMR_SIZE' MUST be
N*                           configured so that ALL bits in 'CPU_TS_TMR' data type are significant.
N*
N*                           In other words, if timer size is not a binary-multiple of 8-bit octets
N*                           (e.g. 20-bits or even 24-bits), then the next lower, binary-multiple
N*                           octet word size SHOULD be configured (e.g. to 16-bits).  However, the
N*                           minimum supported word size for CPU timestamp timers is 8-bits.
N*
N*                       See also 'cpu_cfg.h   CPU TIMESTAMP CONFIGURATION  Note #2'
N*                              & 'cpu_core.h  CPU TIMESTAMP DATA TYPES     Note #1'.
N*
N*                   (b) Timer SHOULD be an 'up'  counter whose values increase with each time count.
N*
N*                       (1) If timer is a 'down' counter whose values decrease with each time count,
N*                           then the returned timer value MUST be ones-complemented.
N*
N*                   (c) (1) When applicable, the amount of time measured by CPU timestamps is
N*                           calculated by either of the following equations :
N*
N*                           (A) Time measured  =  Number timer counts  *  Timer period
N*
N*                                   where
N*
N*                                       Number timer counts     Number of timer counts measured
N*                                       Timer period            Timer's period in some units of
N*                                                                   (fractional) seconds
N*                                       Time measured           Amount of time measured, in same
N*                                                                   units of (fractional) seconds
N*                                                                   as the Timer period
N*
N*                                                  Number timer counts
N*                           (B) Time measured  =  ---------------------
N*                                                    Timer frequency
N*
N*                                   where
N*
N*                                       Number timer counts     Number of timer counts measured
N*                                       Timer frequency         Timer's frequency in some units
N*                                                                   of counts per second
N*                                       Time measured           Amount of time measured, in seconds
N*
N*                       (2) Timer period SHOULD be less than the typical measured time but MUST be less
N*                           than the maximum measured time; otherwise, timer resolution inadequate to
N*                           measure desired times.
N*********************************************************************************************************
N*/
N
N#if (CPU_CFG_TS_TMR_EN == DEF_ENABLED)
X#if (1u == 1u)
NCPU_TS_TMR  CPU_TS_TmrRd (void)
N{
N    CPU_TS_TMR  ts_tmr_cnts;
N
N    ts_tmr_cnts = (CPU_TS_TMR)CPU_REG_DWT_CYCCNT;
X    ts_tmr_cnts = (CPU_TS_TMR)(*(CPU_REG32 *)0xE0001004);
N
N    return (ts_tmr_cnts);
N}
N#endif
N
N
N/*
N*********************************************************************************************************
N*                                         CPU_TSxx_to_uSec()
N*
N* Description : Convert a 32-/64-bit CPU timestamp from timer counts to microseconds.
N*
N* Argument(s) : ts_cnts   CPU timestamp (in timestamp timer counts [see Note #2aA]).
N*
N* Return(s)   : Converted CPU timestamp (in microseconds           [see Note #2aD]).
N*
N* Caller(s)   : Application.
N*
N*               This function is an (optional) CPU module application programming interface (API)
N*               function which MAY be implemented by application/BSP function(s) [see Note #1] &
N*               MAY be called by application function(s).
N*
N* Note(s)     : (1) CPU_TS32_to_uSec()/CPU_TS64_to_uSec() are application/BSP functions that MAY be
N*                   optionally defined by the developer when either of the following CPU features is
N*                   enabled :
N*
N*                   (a) CPU timestamps
N*                   (b) CPU interrupts disabled time measurements
N*
N*                   See 'cpu_cfg.h  CPU TIMESTAMP CONFIGURATION  Note #1'
N*                     & 'cpu_cfg.h  CPU INTERRUPTS DISABLED TIME MEASUREMENT CONFIGURATION  Note #1a'.
N*
N*               (2) (a) The amount of time measured by CPU timestamps is calculated by either of
N*                       the following equations :
N*
N*                                                                        10^6 microseconds
N*                       (1) Time measured  =   Number timer counts   *  -------------------  *  Timer period
N*                                                                            1 second
N*
N*                                              Number timer counts       10^6 microseconds
N*                       (2) Time measured  =  ---------------------  *  -------------------
N*                                                Timer frequency             1 second
N*
N*                               where
N*
N*                                   (A) Number timer counts     Number of timer counts measured
N*                                   (B) Timer frequency         Timer's frequency in some units
N*                                                                   of counts per second
N*                                   (C) Timer period            Timer's period in some units of
N*                                                                   (fractional)  seconds
N*                                   (D) Time measured           Amount of time measured,
N*                                                                   in microseconds
N*
N*                   (b) Timer period SHOULD be less than the typical measured time but MUST be less
N*                       than the maximum measured time; otherwise, timer resolution inadequate to
N*                       measure desired times.
N*
N*                   (c) Specific implementations may convert any number of CPU_TS32 or CPU_TS64 bits
N*                       -- up to 32 or 64, respectively -- into microseconds.
N*********************************************************************************************************
N*/
N
N#if (CPU_CFG_TS_32_EN == DEF_ENABLED)
X#if (1u == 1u)
NCPU_INT64U  CPU_TS32_to_uSec (CPU_TS32  ts_cnts)
N{
N    CPU_INT64U  ts_us;
N    CPU_INT64U  fclk_freq;
N
N    fclk_freq = BSP_CPU_ClkFreq();
N    ts_us     = ts_cnts / (fclk_freq / DEF_TIME_NBR_uS_PER_SEC);
X    ts_us     = ts_cnts / (fclk_freq / 1000000u);
N
N    return (ts_us);
N}
N#endif
N
N
N#if (CPU_CFG_TS_64_EN == DEF_ENABLED)
X#if (0u == 1u)
SCPU_INT64U  CPU_TS64_to_uSec (CPU_TS64  ts_cnts)
S{
S    CPU_INT64U  ts_us;
S    CPU_INT64U  fclk_freq;
S
S
S    fclk_freq = BSP_CPU_ClkFreq();
S    ts_us     = ts_cnts / (fclk_freq / DEF_TIME_NBR_uS_PER_SEC);
S
S    return (ts_us);
S}
N#endif
N