Net_Config.lst 654 KB

Edit Raw Blame History

L 1 "..\..\RL-ARM\Config\Net_Config.c"
N/*----------------------------------------------------------------------------
N *      RL-ARM - TCPnet
N *----------------------------------------------------------------------------
N *      Name:    NET_CONFIG.C
N *      Purpose: Configuration of RL TCPnet by user
N *      Rev.:    V4.72
N *----------------------------------------------------------------------------
N *      This code is part of the RealView Run-Time Library.
N *      Copyright (c) 2004-2013 KEIL - An ARM Company. All rights reserved.
N *---------------------------------------------------------------------------*/
N
N#include <Net_Config.h>
L 1 "..\..\RL-ARM\Config\Net_Config.h" 1
N/*----------------------------------------------------------------------------
N *      RL-ARM - TCPnet
N *----------------------------------------------------------------------------
N *      Name:    NET_CONFIG.H
N *      Purpose: Common TCPnet Definitions
N *      Rev.:    V4.73
N *----------------------------------------------------------------------------
N *      This code is part of the RealView Run-Time Library.
N *      Copyright (c) 2004-2013 KEIL - An ARM Company. All rights reserved.
N *---------------------------------------------------------------------------*/
N
N#ifndef __NET_CONFIG_H__
N#define __NET_CONFIG_H__
N
N#include <RTL.h>
L 1 "..\..\RL-ARM\RL-RTX\inc\RTL.h" 1
N/*----------------------------------------------------------------------------
N *      RL-ARM - A P I
N *----------------------------------------------------------------------------
N *      Name:    RTL.H
N *      Purpose: Application Programming Interface
N *      Rev.:    V4.73
N *----------------------------------------------------------------------------
N *      This code is part of the RealView Run-Time Library.
N *      Copyright (c) 2004-2013 KEIL - An ARM Company. All rights reserved.
N *---------------------------------------------------------------------------*/
N
N#ifndef __RTL_H__
N#define __RTL_H__
N//#include "port.h"
N/* RL-ARM version number. */
N#define __RL_ARM_VER    473
N
N#define __task          __declspec(noreturn)
N#define __used          __attribute__((used))
N
N#ifndef NULL
N #ifdef __cplusplus
S  #define NULL          0
N #else
N  #define NULL          ((void *) 0)
N #endif
N#endif
N
N#ifndef EOF
N #define EOF            (-1)
N#endif
N
N#ifndef __size_t
N #define __size_t       1
N typedef unsigned int   size_t;
N#endif
N
Ntypedef signed char     S8;
Ntypedef unsigned char   U8;
Ntypedef short           S16;
Ntypedef unsigned short  U16;
Ntypedef int             S32;
Ntypedef unsigned int    U32;
Ntypedef long long       S64;
Ntypedef unsigned long long U64;
Ntypedef unsigned char   BIT;
Ntypedef unsigned int    BOOL;
N
N#ifndef __TRUE
N #define __TRUE         1
N#endif
N#ifndef __FALSE
N #define __FALSE        0
N#endif
N
N#ifdef __BIG_ENDIAN
S #define U32_LE(v)      (U32)(__rev(v))
S #define U16_LE(v)      (U16)(__rev(v) >> 16)
S #define U32_BE(v)      (U32)(v)
S #define U16_BE(v)      (U16)(v)
N#else
N #define U32_BE(v)      (U32)(__rev(v))
N #define U16_BE(v)      (U16)(__rev(v) >> 16)
N #define U32_LE(v)      (U32)(v)
N #define U16_LE(v)      (U16)(v)
N#endif
N#define ntohs(v)        U16_BE(v)
N#define ntohl(v)        U32_BE(v)
N#define htons(v)        ntohs(v)
N#define htonl(v)        ntohl(v)
N
N/*----------------------------------------------------------------------------
N *                             RTX Kernel API
N *---------------------------------------------------------------------------*/
N
N#ifdef __cplusplus
Sextern "C"  {
N#endif
N
N/*----------------------------------------------------------------------------
N *                        Flash File System API
N *---------------------------------------------------------------------------*/
N
N/* File System Type */
Ntypedef enum _FS_TYPE {
N  FS_TYPE_NONE = 0,                     /* No file system (volume unformatted)*/
N  FS_TYPE_UNKNOWN,                      /* File system type is unknown       */
N  FS_TYPE_FAT12,                        /* File system type is FAT12         */
N  FS_TYPE_FAT16,                        /* File system type is FAT16         */
N  FS_TYPE_FAT32,                        /* File system type is FAT32         */
N  FS_TYPE_EFS                           /* File system type is EFS           */
N} FS_TYPE;
N
Ntypedef struct {                        /* RL Time format (FFS, TCPnet)      */
N  U8  hr;                               /* Hours    [0..23]                  */
N  U8  min;                              /* Minutes  [0..59]                  */
N  U8  sec;                              /* Seconds  [0..59]                  */
N  U8  day;                              /* Day      [1..31]                  */
N  U8  mon;                              /* Month    [1..12]                  */
N  U16 year;                             /* Year     [1980..2107]             */
N} RL_TIME;
N
Ntypedef struct {                        /* Search info record                */
N  S8  name[256];                        /* Name                              */
N  U32 size;                             /* File size in bytes                */
N  U16 fileID;                           /* System Identification             */
N  U8  attrib;                           /* Attributes                        */
N  RL_TIME time;                         /* Create/Modify Time                */
N} FINFO;
N
N/* Drive information */
Ntypedef struct {
N  FS_TYPE fs_type;                      /* Drives file system type           */
N  U64     capacity;                     /* Drives capacity in bytes          */
N} Drive_INFO;
N
Nextern int finit (const char *drive);
Nextern int funinit (const char *drive);
Nextern int fdelete (const char *filename);
Nextern int frename (const char *oldname, const char *newname);
Nextern int ffind (const char *pattern, FINFO *info);
Nextern U64 ffree (const char *drive);
Nextern int fformat (const char *drive);
Nextern int fanalyse (const char *drive);
Nextern int fcheck (const char *drive);
Nextern int fdefrag (const char *drive);
Nextern int fattrib (const char *par, const char *path);
Nextern int fvol    (const char *drive, char *buf);
Nextern int finfo   (const char *drive, Drive_INFO *info);
N
N/* The following macros provide for common functions */
N#define unlink(fn)      fdelete(fn);
N
N/*----------------------------------------------------------------------------
N *                             TCPnet API
N *---------------------------------------------------------------------------*/
N
N/* UDP Options */
N#define UDP_OPT_SEND_CS    0x01   /* Calculate Checksum for UDP send frames  */
N#define UDP_OPT_CHK_CS     0x02   /* Verify Checksum for received UDP frames */
N
N/* TCP Socket Types */
N#define TCP_TYPE_SERVER    0x01   /* Socket Type Server (open for listening) */
N#define TCP_TYPE_CLIENT    0x02   /* Socket Type Client (initiate connect)   */
N#define TCP_TYPE_DELAY_ACK 0x04   /* Socket Type Delayed Acknowledge         */
N#define TCP_TYPE_FLOW_CTRL 0x08   /* Socket Type Flow Control                */
N#define TCP_TYPE_KEEP_ALIVE 0x10  /* Socket Type Keep Alive                  */
N#define TCP_TYPE_CLIENT_SERVER (TCP_TYPE_SERVER | TCP_TYPE_CLIENT)
N
N/* TCP Callback Events */
N#define TCP_EVT_CONREQ     0      /* Connect request received event          */
N#define TCP_EVT_CONNECT    1      /* Connection established event            */
N#define TCP_EVT_CLOSE      2      /* Connection was properly closed          */
N#define TCP_EVT_ABORT      3      /* Connection is for some reason aborted   */
N#define TCP_EVT_ACK        4      /* Previously send data acknowledged       */
N#define TCP_EVT_DATA       5      /* Data received event                     */
N
N/* TCP States */
N#define TCP_STATE_FREE     0      /* Entry is free and unused                */
N#define TCP_STATE_CLOSED   1      /* Entry allocated, socket still closed    */
N#define TCP_STATE_LISTEN   2      /* Socket waiting for incoming connection  */
N#define TCP_STATE_SYN_REC  3      /* SYN frame received                      */
N#define TCP_STATE_SYN_SENT 4      /* SYN packet sent to establish a connect. */
N#define TCP_STATE_FINW1    5      /* Tcp_close started FIN packet was sent   */
N#define TCP_STATE_FINW2    6      /* Our FIN ack-ed, waiting for remote FIN  */
N#define TCP_STATE_CLOSING  7      /* Received FIN independently of our FIN   */
N#define TCP_STATE_LAST_ACK 8      /* Waiting for last ACK for our FIN        */
N#define TCP_STATE_TWAIT    9      /* Timed waiting for 2MSL                  */
N#define TCP_STATE_CONNECT  10     /* TCP Connection established              */
N
N/* BSD Socket Address Family */
N#define AF_UNSPEC          0      /* Unspecified                             */
N#define AF_INET            1      /* Internet Address Family (UDP, TCP)      */
N#define AF_NETBIOS         2      /* NetBios-style addresses                 */
N
N/* BSD Protocol families, same as address families */
N#define PF_UNSPEC          AF_UNSPEC
N#define PF_INET            AF_INET
N#define PF_NETBIOS         AF_NETBIOS
N
N/* BSD Socket Type */
N#define SOCK_STREAM        1      /* Stream Socket (Connection oriented)     */
N#define SOCK_DGRAM         2      /* Datagram Socket (Connectionless)        */
N
N/* BSD Socket Protocol */
N#define IPPROTO_TCP        1      /* TCP Protocol                            */
N#define IPPROTO_UDP        2      /* UDP Protocol                            */
N
N/* BSD Internet Addresses */
N#define INADDR_ANY     0x00000000 /* All IP addresses accepted               */
N#define INADDR_NONE    0xffffffff /* No IP address accepted                  */
N
N/* BSD Socket Return values */
N#define SCK_SUCCESS         0     /* Success                                 */
N#define SCK_ERROR         (-1)    /* General Error                           */
N#define SCK_EINVALID      (-2)    /* Invalid socket descriptor               */
N#define SCK_EINVALIDPARA  (-3)    /* Invalid parameter                       */
N#define SCK_EWOULDBLOCK   (-4)    /* It would have blocked.                  */
N#define SCK_EMEMNOTAVAIL  (-5)    /* Not enough memory in memory pool        */
N#define SCK_ECLOSED       (-6)    /* Connection is closed or aborted         */
N#define SCK_ELOCKED       (-7)    /* Socket is locked in RTX environment     */
N#define SCK_ETIMEOUT      (-8)    /* Socket, Host Resolver timeout           */
N#define SCK_EINPROGRESS   (-9)    /* Host Name resolving in progress         */
N#define SCK_ENONAME       (-10)   /* Host Name not existing                  */
N
N/* BSD Socket flags parameter */
N#define MSG_DONTWAIT       0x01   /* Enables non-blocking operation          */
N#define MSG_PEEK           0x02   /* Peeks at the incoming data              */
N
N/* BSD Socket ioctl commands */
N#define FIONBIO            1      /* Set mode (blocking/non-blocking)        */
N#define FIO_DELAY_ACK      2      /* Set DELAY_ACK mode for stream socket    */
N#define FIO_KEEP_ALIVE     3      /* Set KEEP_ALIVE mode for stream socket   */
N#define FIO_FLOW_CTRL      4      /* Set FLOW_CTRL mode for stream socket    */
N
N/* ICMP (ping) Callback Events */
N#define ICMP_EVT_SUCCESS   0      /* Pinged Host responded                   */
N#define ICMP_EVT_TIMEOUT   1      /* Timeout, no ping response received      */
N
N/* DNS Client Callback Events */
N#define DNS_EVT_SUCCESS    0      /* Host name successfully resolved         */
N#define DNS_EVT_NONAME     1      /* DNS Error, no such name                 */
N#define DNS_EVT_TIMEOUT    2      /* Timeout resolving host                  */
N#define DNS_EVT_ERROR      3      /* Erroneous response packet               */
N
N/* DNS 'get_host_by_name()' result codes */
N#define DNS_RES_OK         0      /* Resolver successfully started           */
N#define DNS_ERROR_BUSY     1      /* Resolver busy, can't process request    */
N#define DNS_ERROR_LABEL    2      /* Label in Hostname not valid             */
N#define DNS_ERROR_NAME     3      /* Entire Hostname not valid               */
N#define DNS_ERROR_NOSRV    4      /* Prim. DNS server not specified (0.0.0.0)*/
N#define DNS_ERROR_PARAM    5      /* Invalid parameter                       */
N
N/* SMTP Client Callback Events */
N#define SMTP_EVT_SUCCESS   0      /* Email successfully sent                 */
N#define SMTP_EVT_TIMEOUT   1      /* Timeout sending email                   */
N#define SMTP_EVT_ERROR     2      /* Error when sending email                */
N
N/* FTP Client Commands */
N#define FTPC_CMD_PUT       0      /* Puts a file on FTP server               */
N#define FTPC_CMD_GET       1      /* Retrieves a file from FTP server        */
N#define FTPC_CMD_APPEND    2      /* Append file on FTP server (with create) */
N#define FTPC_CMD_DELETE    3      /* Deletes a file on FTP server            */
N#define FTPC_CMD_LIST      4      /* Lists files stored on FTP server        */
N#define FTPC_CMD_RENAME    5      /* Renames a file on FTP server            */
N#define FTPC_CMD_MKDIR     6      /* Makes a directory on FTP server         */
N#define FTPC_CMD_RMDIR     7      /* Removes an empty directory on FTP server*/
N#define FTPC_CMD_NLIST     8      /* Lists file names only (short format)    */
N
N/* FTP Client Callback Events */
N#define FTPC_EVT_SUCCESS   0      /* File operation successful               */
N#define FTPC_EVT_TIMEOUT   1      /* Timeout on file operation               */
N#define FTPC_EVT_LOGINFAIL 2      /* Login error, username/passw invalid     */
N#define FTPC_EVT_NOACCESS  3      /* File access not allowed                 */
N#define FTPC_EVT_NOTFOUND  4      /* File not found                          */
N#define FTPC_EVT_NOPATH    5      /* Working directory path not found        */
N#define FTPC_EVT_ERRLOCAL  6      /* Local file open error                   */
N#define FTPC_EVT_ERROR     7      /* Generic FTP client error                */
N
N/* TFTP Client Callback Events */
N#define TFTPC_EVT_SUCCESS  0      /* File operation successful               */
N#define TFTPC_EVT_TIMEOUT  1      /* Timeout on file operation               */
N#define TFTPC_EVT_NOACCESS 2      /* File access not allowed                 */
N#define TFTPC_EVT_NOTFOUND 3      /* File not found                          */
N#define TFTPC_EVT_DISKFULL 4      /* Disk full (local or remote)             */
N#define TFTPC_EVT_ERROR    5      /* Generic TFTP client error               */
N
N/* FTP Server Notification events */
N#define FTP_EVT_LOGIN      0      /* User logged in, session is busy         */
N#define FTP_EVT_LOGOUT     1      /* User logged out, session is idle        */
N#define FTP_EVT_LOGFAIL    2      /* User login failed (invalid credentials) */
N#define FTP_EVT_DOWNLOAD   3      /* File download ended                     */
N#define FTP_EVT_UPLOAD     4      /* File upload ended                       */
N#define FTP_EVT_DELETE     5      /* File deleted                            */
N#define FTP_EVT_RENAME     6      /* File or directory renamed               */
N#define FTP_EVT_MKDIR      7      /* Directory created                       */
N#define FTP_EVT_RMDIR      8      /* Directory removed                       */
N#define FTP_EVT_ERRLOCAL   9      /* Local file operation error              */
N#define FTP_EVT_DENIED     10     /* Requested file operation denied         */
N#define FTP_EVT_ERROR      11     /* Generic file operation error            */
N
N/* ARP Cache Entry types */
N#define ARP_FIXED_IP       0      /* Fixed IP adrs is refreshed after tout   */
N#define ARP_TEMP_IP        1      /* Temp adrs is removed after timeout      */
N
N/* BSD Socket typedef's */
Ntypedef struct sockaddr {         /* << Generic Socket Address structure >>  */
N  U16  sa_family;                 /* Address family                          */
N  char sa_data[14];               /* Direct address (up to 14 bytes)         */
N} SOCKADDR;
N
N#pragma push
N#pragma anon_unions
N
Ntypedef struct in_addr {          /* << Generic IPv4 Address structure >>    */
N  union {
N    struct {
N      U8 s_b1,s_b2,s_b3,s_b4;     /* IP address, byte access                 */
N    };
N    struct {
N      U16 s_w1,s_w2;              /* IP address, short int access            */
N    };
N    U32 s_addr;                   /* IP address in network byte order        */
N  };
N} IN_ADDR;
N#pragma pop
N
Ntypedef struct sockaddr_in {      /* << IPv4 Socket Address structure >>     */
N  S16 sin_family;                 /* Socket domain                           */
N  U16 sin_port;                   /* Port                                    */
N  IN_ADDR sin_addr;               /* IP address                              */
N  S8  sin_zero[8];                /* reserved                                */
N} SOCKADDR_IN;
N
Ntypedef struct hostent {          /* << BSD Host Entry structure >>          */
N  char *h_name;                   /* Official name of host                   */
N  char **h_aliases;               /* Pointer to an array of alias names      */
N  S16  h_addrtype;                /* Address Type: AF_INET, AF_NETBIOS       */
N  S16  h_length;                  /* Length of address in bytes              */
N  char **h_addr_list;             /* Pointer to an array of IPv4 addresses   */
N} HOSTENT;
N
Nextern void init_TcpNet (void);
Nextern BOOL main_TcpNet (void);
Nextern void timer_tick (void);
Nextern U8   udp_get_socket (U8 tos, U8 opt,
N                            U16 (*listener)(U8 socket, U8 *remip, U16 port, U8 *buf, U16 len));
Nextern BOOL udp_release_socket (U8 socket);
Nextern BOOL udp_open (U8 socket, U16 locport);
Nextern BOOL udp_close (U8 socket);
Nextern BOOL udp_mcast_ttl (U8 socket, U8 ttl);
Nextern U8  *udp_get_buf (U16 size);
Nextern BOOL udp_send (U8 socket, U8 *remip, U16 remport, U8 *buf, U16 dlen);
Nextern U8   tcp_get_socket (U8 type, U8 tos, U16 tout,
N                            U16 (*listener)(U8 socket, U8 event, U8 *buf, U16 len));
Nextern BOOL tcp_release_socket (U8 socket);
Nextern BOOL tcp_listen (U8 socket, U16 locport);
Nextern BOOL tcp_connect (U8 socket, U8 *remip, U16 remport, U16 locport);
Nextern U8  *tcp_get_buf (U16 size);
Nextern U16  tcp_max_dsize (U8 socket);
Nextern BOOL tcp_check_send (U8 socket);
Nextern U8   tcp_get_state (U8 socket);
Nextern BOOL tcp_send (U8 socket, U8 *buf, U16 dlen);
Nextern BOOL tcp_close (U8 socket);
Nextern BOOL tcp_abort (U8 socket);
Nextern void tcp_reset_window (U8 socket);
Nextern BOOL arp_cache_ip (U8 *ipadr, U8 type);
Nextern BOOL arp_cache_mac (U8 *hwadr);
Nextern void ppp_listen (const char *user, const char *passw);
Nextern void ppp_connect (const char *dialnum, const char *user, const char *passw);
Nextern void ppp_close (void);
Nextern BOOL ppp_is_up (void);
Nextern void slip_listen (void);
Nextern void slip_connect (const char *dialnum);
Nextern void slip_close (void);
Nextern BOOL slip_is_up (void);
Nextern U8   get_host_by_name (U8 *hostn, void (*cbfunc)(U8 event, U8 *host_ip));
Nextern BOOL smtp_connect (U8 *ipadr, U16 port, void (*cbfunc)(U8 event));
Nextern void dhcp_disable (void);
Nextern BOOL igmp_join (U8 *group_ip);
Nextern BOOL igmp_leave (U8 *group_ip);
Nextern BOOL snmp_trap (U8 *manager_ip, U8 gen_trap, U8 spec_trap, U16 *obj_list);
Nextern BOOL snmp_set_community (const char *community);
Nextern BOOL icmp_ping (U8 *remip, void (*cbfunc)(U8 event));
Nextern BOOL ftpc_connect (U8 *ipadr, U16 port, U8 command, void (*cbfunc)(U8 event));
Nextern BOOL tftpc_put (U8 *ipadr, U16 port,
N                       const char *src, const char *dst, void (*cbfunc)(U8 event));
Nextern BOOL tftpc_get (U8 *ipadr, U16 port,
N                       const char *src, const char *dst, void (*cbfunc)(U8 event));
Nextern BOOL sntp_get_time (U8 *ipadr, void (*cbfunc)(U32 utc_time));
Nextern void ftp_evt_notify (U8 evt);
N
N/* BSD Socket API */
Nextern int  socket (int family, int type, int protocol);
Nextern int  bind (int sock, const SOCKADDR *addr, int addrlen);
Nextern int  listen (int sock, int backlog);
Nextern int  accept (int sock, SOCKADDR *addr, int *addrlen);
Nextern int  connect (int sock, SOCKADDR *addr, int addrlen);
Nextern int  send (int sock, const char *buf, int len, int flags);
Nextern int  sendto (int sock, const char *buf, int len, int flags, SOCKADDR *to, int tolen);
Nextern int  recv (int sock, char *buf, int len, int flags);
Nextern int  recvfrom (int sock, char *buf, int len, int flags, SOCKADDR *from, int *fromlen);
Nextern int  closesocket (int sock);
Nextern int  getpeername (int sock, SOCKADDR *name, int *namelen);
Nextern int  getsockname (int sock, SOCKADDR *name, int *namelen);
Nextern int  ioctlsocket (int sock, long cmd, unsigned long *argp);
Nextern HOSTENT *gethostbyname (const char *name, int *err);
N
N#ifdef __cplusplus
S}
N#endif
N
N/*----------------------------------------------------------------------------
N * end of file
N *---------------------------------------------------------------------------*/
N
N#endif
N
L 16 "..\..\RL-ARM\Config\Net_Config.h" 2
N
N/* Definitions */
N#define ETH_ADRLEN      6         /* Ethernet Address Length in bytes        */
N#define IP_ADRLEN       4         /* IP Address Length in bytes              */
N#define OS_HEADER_LEN   4         /* TCPnet 'os_frame' header size           */
N                                  /* Frame Header length common for all      */
N#define PHY_HEADER_LEN  (2*ETH_ADRLEN + 2) /* network interfaces.            */
N#define ETH_MTU         1514      /* Ethernet Frame Max Transfer Unit        */
N#define PPP_PROT_IP     0x0021    /* PPP Protocol type: IP                   */
N#define TCP_DEF_WINSIZE 4380      /* TCP default window size                 */
N#define PASSW_SZ        20        /* Authentication Password Buffer size     */
N
N/* Network Interfaces */
N#define NETIF_ETH       0         /* Network interface: Ethernet             */
N#define NETIF_PPP       1         /* Network interface: PPP                  */
N#define NETIF_SLIP      2         /* Network interface: Slip                 */
N#define NETIF_LOCAL     3         /* Network interface: Localhost (loopback) */
N#define NETIF_NULL      4         /* Network interface: Null (none)          */
N
N/* Telnet Definitions */
N#define TNET_LBUFSZ     96        /* Command Line buffer size (bytes)        */
N#define TNET_HISTSZ     128       /* Command History buffer size (bytes)     */
N#define TNET_FIFOSZ     128       /* Input character Fifo buffer (bytes)     */
N
N/* SNMP-MIB Definitions */
N#define MIB_INTEGER     0x02      /* MIB entry type INTEGER                  */
N#define MIB_OCTET_STR   0x04      /* MIB entry type OCTET_STRING             */
N#define MIB_OBJECT_ID   0x06      /* MIB entry type OBJECT_IDENTIFIER        */
N#define MIB_IP_ADDR     0x40      /* MIB entry type IP ADDRESS (U8[4])       */
N#define MIB_COUNTER     0x41      /* MIB entry type COUNTER (U32)            */
N#define MIB_GAUGE       0x42      /* MIB entry type GAUGE (U32)              */
N#define MIB_TIME_TICKS  0x43      /* MIB entry type TIME_TICKS               */
N#define MIB_ATR_RO      0x80      /* MIB entry attribute READ_ONLY           */
N#define MIB_OIDSZ       17        /* Max.size of Object ID value             */
N#define MIB_STRSZ       110       /* Max.size of Octet String variable       */
N#define MIB_READ        0         /* MIB entry Read access                   */
N#define MIB_WRITE       1         /* MIB entry Write access                  */
N
N/* SNMP-MIB Macros */
N#define MIB_STR(s)      sizeof(s)-1, s
N#define MIB_INT(o)      sizeof(o), (void *)&o
N#define MIB_IP(ip)      4, (void *)&ip
N#define OID0(f,s)       (f*40 + s)
N
N/* Debug Module Definitions */
N#define MODULE_MEM      0         /* Dynamic Memory Module ID                */
N#define MODULE_ETH      1         /* Ethernet Module ID                      */
N#define MODULE_PPP      2         /* PPP Module ID                           */
N#define MODULE_SLIP     3         /* SLIP Module ID                          */
N#define MODULE_ARP      4         /* ARP Module ID                           */
N#define MODULE_IP       5         /* IP Module ID                            */
N#define MODULE_ICMP     6         /* ICMP Module ID                          */
N#define MODULE_IGMP     7         /* IGMP Module ID                          */
N#define MODULE_UDP      8         /* UDP Module ID                           */
N#define MODULE_TCP      9         /* TCP Module ID                           */
N#define MODULE_NBNS     10        /* NBNS Module ID                          */
N#define MODULE_DHCP     11        /* DHCP Module ID                          */
N#define MODULE_DNS      12        /* DNS Module ID                           */
N#define MODULE_SNMP     13        /* SNMP Module ID                          */
N#define MODULE_BSD      14        /* BSD Socket Module ID                    */
N#define MODULE_HTTP     15        /* HTTP Server Module ID                   */
N#define MODULE_FTP      16        /* FTP Server Module ID                    */
N#define MODULE_FTPC     17        /* FTP Client Module ID                    */
N#define MODULE_TNET     18        /* Telnet Server Module ID                 */
N#define MODULE_TFTP     19        /* TFTP Server Module ID                   */
N#define MODULE_TFTPC    20        /* TFTP Client Module ID                   */
N#define MODULE_SMTP     21        /* SMTP Client Module ID                   */
N#define MODULE_SNTP     22        /* SNTP Client Module ID                   */
N
N/*---------------------------------------------------------------------------*/
N
N#ifdef __cplusplus
Sextern "C"  {
N#endif
N
Ntypedef struct os_frame {         /* << System frame buffer structure >>     */
N  U16 length;                     /* Total Length of data in frame           */
N  U16 index;                      /* Buffer Position Index                   */
N  U8  data[1];                    /* Buffer data (protocol headers + data)   */
N} OS_FRAME;
N
Ntypedef struct arp_info {         /* << ARP Cache Entry info >>              */
N  U8  State;                      /* ARP Cache entry current state           */
N  U8  Type;                       /* Cache Entry type                        */
N  U8  Retries;                    /* Number of Retries left                  */
N  U8  Tout;                       /* Cache Entry Timeout                     */
N  U8  HwAdr[ETH_ADRLEN];          /* Ethernet Hardware Address               */
X  U8  HwAdr[6];
N  U8  IpAdr[IP_ADRLEN];           /* Ethernet IP Address                     */
X  U8  IpAdr[4];
N} ARP_INFO;
N
Ntypedef struct igmp_info {        /* << IGMP Group info >>                   */
N  U8  State;                      /* Group membership current state          */
N  U8  Tout;                       /* Timeout Timer for sending reports       */
N  U8  Flags;                      /* State machine flags                     */
N  U8  GrpIpAdr[IP_ADRLEN];        /* Group IP address                        */
X  U8  GrpIpAdr[4];
N} IGMP_INFO;
N
Ntypedef struct udp_info {         /* << UDP Socket info >>                   */
N  U8  State;                      /* UDP Socket entry current state          */
N  U8  Opt;                        /* UDP Socket Options                      */
N  U8  Flags;                      /* State machine flags                     */
N  U8  Tos;                        /* UDP Type of Service                     */
N  U16 LocPort;                    /* Local UDP port of Socket                */
N  U8  McastTtl;                   /* MultiCast Time To Live                  */
N                                  /* Application Event CallBack function     */
N  U16 (*cb_func)(U8 socket, U8 *rem_ip, U16 port, U8 *buf, U16 len);
N} UDP_INFO;
N
Ntypedef struct tcp_info {         /* << TCP Socket info >>                   */
N  U8  State;                      /* Socket entry current state              */
N  U8  Type;                       /* Socket type                             */
N  U8  Flags;                      /* State machine flags                     */
N  U8  Tos;                        /* Type of service allocated               */
N  U8  RemIpAdr[IP_ADRLEN];        /* Remote IP address                       */
X  U8  RemIpAdr[4];
N  U16 RemPort;                    /* Remote TCP port                         */
N  U16 LocPort;                    /* Local TCP port                          */
N  U16 MaxSegSize;                 /* Transmit Max. Segment Size              */
N  U16 Tout;                       /* Socket idle timeout (in seconds)        */
N  U16 AliveTimer;                 /* Keep Alive timer                        */
N  U16 RetryTimer;                 /* Retransmission timer                    */
N  U8  AckTimer;                   /* Receive Delay-ack timer                 */
N  U8  Id;                         /* Socket identification number            */
N  U8  Retries;                    /* Number of retries left before aborting  */
N  U8  DupAcks;                    /* Number of duplicate acks (fast recovery)*/
N  U32 SendUna;                    /* Send Sequence Number unacknowledged     */
N  U32 SendNext;                   /* Next Send Sequence Number               */
N  U32 SendChk;                    /* Check Sequence Number for dupacks       */
N  U32 SendWl1;                    /* Sequence Number of last Window update   */
N  U32 SendWl2;                    /* Acknowledge Number of last Window update*/
N  U16 SendWin;                    /* Current Send Window                     */
N  S16 RttSa;                      /* Scaled Average for RTT estimator        */
N  S16 RttSv;                      /* Scaled deViation for RTT estimator      */
N  U16 CWnd;                       /* Congestion Window                       */
N  U16 SsThresh;                   /* Slow Start Treshold                     */
N  U16 RecWin;                     /* Current Receive Window                  */
N  U32 RecNext;                    /* Next Receive Sequence Number            */
N  OS_FRAME *unack_list;           /* Unacked queue list                      */
N                                  /* Application Event-CallBack function     */
N  U16 (*cb_func)(U8 socket, U8 event, U8 *p1, U16 p2);
N} TCP_INFO;
N
Ntypedef struct bsd_info {         /* << BSD Socket info >>                   */
N  U8  State;                      /* BSD Socket current state                */
N  U8  Socket;                     /* Binded TCP/UDP Socket                   */
N  U8  Flags;                      /* Flags for Socket Option                 */
N  U8  Type;                       /* Type of Socket (SOCK_DGRAM/SOCK_STREAM) */
N  U16 LocPort;                    /* Bind local Port                         */
N  U16 RemPort;                    /* Remote TCP/UDP Port                     */
N  U32 LocIP;                      /* Bind local IP address (net byte order)  */
N  U32 RemIP;                      /* Remote IP address     (net byte order)  */
N  U8  AcceptSock;                 /* Accept Socket list                      */
N  U8  ParentSock;                 /* Parent (server) socket                  */
N  U8  Event;                      /* Wait Event flags in RTX environment     */
N  U8  Task;                       /* Socket Owner Task                       */
N  U16 Tout;                       /* Receive timer value                     */
N  void *buf_list;                 /* Rx Data buffer chain                    */
N} BSD_INFO;
N
Ntypedef struct http_info {        /* << HTTP Session info >>                 */
N  U8  State;                      /* HTTP Session current state              */
N  U8  Socket;                     /* binded TCP Socket                       */
N  U16 Flags;                      /* State machine Flags                     */
N  U8  FType;                      /* File Type: html, jpeg, gif,...          */
N  U8  PostSt;                     /* POST method Processing Status           */
N  U16 DelimSz;                    /* Boundary delimiter size                 */
N  U8  UserId;                     /* User Id (authentication enabled)        */
N  U32 CGIvar;                     /* CGI session private variable (cgi_func) */
N  U32 DLen;                       /* Data length (number of bytes to send)   */
N  U32 Count;                      /* Total number of bytes sent              */
N  U16 BCnt;                       /* Number of bytes sent in last packet     */
N  U8  Lang[6];                    /* Selected Web Language: en-us, de, fr .. */
N  U32 LMDate;                     /* Last Modified Date (UTC format)         */
N  U8 *Script;                     /* Script Buffer pointer                   */
N  U8 *pDelim;                     /* Multipart Boundary delimiter value      */
N  void *sFile;                    /* Script Interpreter File pointer         */
N  void *dFile;                    /* Data File pointer                       */
N} HTTP_INFO;
N
Ntypedef struct http_file {        /* << HTTP Internal File info >>           */
N  U32       Id;                   /* File Name Id (CRC32 value of file name) */
N  const U8 *Start;                /* File Start Address in ROM               */
N} const HTTP_FILE;
N
Ntypedef struct tnet_info {        /* << Telnet Session info >>               */
N  U8  State;                      /* Telnet Session current state            */
N  U8  Socket;                     /* binded TCP Socket                       */
N  U8  Flags;                      /* State machine Flags                     */
N  U8  BCnt;                       /* Received Data byte count                */
N  U16 Tout;                       /* Timeout delay counter                   */
N  U8  UserId;                     /* User Id (authentication enabled)        */
N  U8  Widx;                       /* Fifo buffer Write index                 */
N  U8  Ridx;                       /* Fifo buffer Read index                  */
N  U8  hNext;                      /* History command next position           */
N  U8  hCurr;                      /* History command current position        */
N  U32 SVar;                       /* Session private var. (tnet_process_cmd) */
N  U8  LBuf[TNET_LBUFSZ];          /* Data Line Buffer                        */
X  U8  LBuf[96];
N  U8  Fifo[TNET_FIFOSZ];          /* Fifo Buffer for received line/keycodes  */
X  U8  Fifo[128];
N  U8  Hist[TNET_HISTSZ];          /* Command History buffer                  */
X  U8  Hist[128];
N} TNET_INFO;
N
Ntypedef struct tftp_info {        /* << TFTP Session info >>                 */
N  U8  State;                      /* TFTP Session current state              */
N  U8  Socket;                     /* binded UDP Data Socket                  */
N  U8  Flags;                      /* State machine Flags                     */
N  U8  Retries;                    /* Retry counter                           */
N  U8  RemIpAdr[IP_ADRLEN];        /* Remote IP address                       */
X  U8  RemIpAdr[4];
N  U16 RemPort;                    /* Remote UDP port (TID)                   */
N  U16 BlockSz;                    /* Transfer Block size                     */
N  U16 BlockNr;                    /* Block Number                            */
N  U8  Timer;                      /* Timeout Timer value                     */
N  U16 BufLen;                     /* Length of retransmit buffer             */
N  U8  *Buf;                       /* Transmit/Retransmit buffer              */
N  void *File;                     /* File Handle pointer                     */
N} TFTP_INFO;
N
Ntypedef struct ftp_info {         /* << FTP Session info >>                  */
N  U8  State;                      /* FTP Session current state               */
N  U8  Socket;                     /* binded TCP Control Socket               */
N  U16 Flags;                      /* State machine Flags                     */
N  U8  RemIpAdr[IP_ADRLEN];        /* Client IP address                       */
X  U8  RemIpAdr[4];
N  U16 DPort;                      /* TCP Data port (Server or Client)        */
N  U8  DSocket;                    /* TCP Data Socket                         */
N  U8  UserId;                     /* User Id (authentication enabled)        */
N  U8  Resp;                       /* FTP Server Response Code                */
N  U8  PathLen;                    /* Size of the Path string                 */
N  U8 *Path;                       /* Current Working Directory               */
N  U8 *Name;                       /* Absolute File/Folder Path Name          */
N  void *File;                     /* File Handle pointer                     */
N} FTP_INFO;
N
Ntypedef struct dns_cache {        /* << DNS Cache Entry info >>              */
N  U32 HostId;                     /* Host Id (CRC32 value of host name)      */
N  U32 Ttl;                        /* Cache Entry Time To Live                */
N  U8  IpAdr[IP_ADRLEN];           /* Ethernet IP Address                     */
X  U8  IpAdr[4];
N} DNS_CACHE;
N
Ntypedef struct localm {           /* << Local Machine info >>                */
N  U8  IpAdr[IP_ADRLEN];           /* Local IP Address                        */
X  U8  IpAdr[4];
N  U8  DefGW[IP_ADRLEN];           /* Default GateWay                         */
X  U8  DefGW[4];
N  U8  NetMask[IP_ADRLEN];         /* Net Mask                                */
X  U8  NetMask[4];
N  U8  PriDNS[IP_ADRLEN];          /* Primary DNS Server                      */
X  U8  PriDNS[4];
N  U8  SecDNS[IP_ADRLEN];          /* Secondary DNS Server                    */
X  U8  SecDNS[4];
N} LOCALM;
N
Ntypedef struct remotem {          /* << Remote Machine Info >>               */
N  U8  IpAdr[IP_ADRLEN];           /* Remote IP address                       */
X  U8  IpAdr[4];
N  U8  HwAdr[ETH_ADRLEN];          /* Remote Hardware Address                 */
X  U8  HwAdr[6];
N} REMOTEM;
N
Ntypedef struct mib_entry {        /* << SNMP-MIB Entry Info >>               */
N  U8  Type;                       /* Object Type                             */
N  U8  OidLen;                     /* Object ID length                        */
N  U8  Oid[MIB_OIDSZ];             /* Object ID value                         */
X  U8  Oid[17];
N  U8  ValSz;                      /* Size of a Variable                      */
N  void *Val;                      /* Pointer to a variable                   */
N  void (*cb_func)(int mode);      /* Write/Read event callback function      */
N} MIB_ENTRY;
N
Ntypedef struct sys_cfg {          /* << SYS Configuration info >>            */
N  U32 *MemPool;                   /* Dynamic Memory Pool buffer              */
N  U32 MemSize;                    /* Memory Pool size in bytes               */
N  U8  TickRate;                   /* Tick Rate in ticks per second           */
N  U8  TickItv;                    /* Tick Interval in ms                     */
N  U8  T200ms;                     /* Delay 200 ms in ticks                   */
N  U8  NetCfg;                     /* Network Interface Configuration flags   */
N  U8 *HostName;                   /* Local Host Name                         */
N} const SYS_CFG;
N
Ntypedef struct arp_cfg {          /* << ARP Configuration info >>            */
N  ARP_INFO *Table;                /* Cache Table array                       */
N  U8  TabSize;                    /* Cache Table size                        */
N  U8  TimeOut;                    /* Table Entry expiration time in seconds  */
N  U8  MaxRetry;                   /* Number of Retries to resolve MAC addr.  */
N  U8  Resend;                     /* Resend Timeout in seconds               */
N  U8  Notify;                     /* Notify on IP address changes             */
N} const ARP_CFG;
N
Ntypedef struct igmp_cfg {         /* << IGMP Configuration info >>           */
N  IGMP_INFO *Table;               /* Group Table array                       */
N  U16 TabSize;                    /* Group Table size                        */
N} const IGMP_CFG;
N
Ntypedef struct dhcp_cfg {         /* << DHCP Configuration info >>           */
N  U8 *Vcid;                       /* Vendor Class Identifier                 */
N  U8  Opt;                        /* Extra DHCP option flags                 */
N} const DHCP_CFG;
N
Ntypedef struct ppp_cfg {          /* << PPP Configuration info >>            */
N  U32 ACCmap;                     /* Async Control Character map             */
N  U16 SerTout;                    /* Serial Frame Receive Timeout            */
N  U16 RetryTout;                  /* Retry Timeout in ticks                  */
N  U16 EchoTout;                   /* LCP Echo Timeout in seconds             */
N  U8  MaxRetry;                   /* Number of Retries                       */
N  U8  EnAuth;                     /* Enabled Authentication protocols        */
N} const PPP_CFG;
N
Ntypedef struct udp_cfg {          /* << UDP Configuration info >>            */
N  UDP_INFO *Scb;                  /* Socket Control Block array              */
N  U8  NumSocks;                   /* Number of UDP Sockets                   */
N} const UDP_CFG;
N
Ntypedef struct tcp_cfg {          /* << TCP Configuration info >>            */
N  TCP_INFO *Scb;                  /* Socket Control Block array              */
N  U8  NumSocks;                   /* Number of TCP Sockets                   */
N  U8  MaxRetry;                   /* Number of Retries                       */
N  U16 RetryTout;                  /* Retry Timeout in ticks                  */
N  U16 T2MSLTout;                  /* Maximum Segment Life Time               */
N  U16 SynRetryTout;               /* SYN Retry Timeout in ticks              */
N  U16 InitRetryTout;              /* Initial Retransmit timeout in ticks     */
N  U16 DefTout;                    /* Default Connect Timeout in seconds      */
N  U16 MaxSegSize;                 /* Maximum Segment Size value              */
N  U16 RecWinSize;                 /* Receiving Window Size in bytes          */
N  U8  ConRetry;                   /* Number of Retries to Connect            */
N} const TCP_CFG;
N
Ntypedef struct http_cfg {         /* << HTTP Configuration info >>           */
N  HTTP_INFO *Scb;                 /* Session Control Block array             */
N  U8  NumSess;                    /* Max. Number of Active Sessions          */
N  U8  EnAuth;                     /* Enable User Authentication              */
N  U16 PortNum;                    /* Listening Port number                   */
N  U8 const *SrvId;                /* Server-Id http header                   */
N  U8 const *Realm;                /* Authentication Realm                    */
N  U8 const *User;                 /* Authentication User name                */
N  U8 *Passw;                      /* Authentication Password                 */
N} const HTTP_CFG;
N
Ntypedef struct tnet_cfg {         /* << TNET Configuration info >>           */
N  TNET_INFO *Scb;                 /* Session Control Block array             */
N  U8  NumSess;                    /* Max. Number of Active Sessions          */
N  U8  EnAuth;                     /* Enable User Authentication              */
N  U8  NoEcho;                     /* Disable Server Echo mode                */
N  U16 PortNum;                    /* Listening Port number                   */
N  U16 IdleTout;                   /* Idle Connection timeout in ticks        */
N  U8 const *User;                 /* Authentication User Name                */
N  U8 *Passw;                      /* Authentication Password                 */
N} const TNET_CFG;
N
Ntypedef struct tftp_cfg {         /* << TFTP Configuration info >>           */
N  TFTP_INFO *Scb;                 /* Session Control Block array             */
N  U8  NumSess;                    /* Max. Number of Active Sessions          */
N  U8  MaxRetry;                   /* Number of Retries                       */
N  U16 PortNum;                    /* Listening Port number                   */
N  U8  DefTout;                    /* Inactive Session Timeout in seconds     */
N  U8  EnFwall;                    /* Enable Firewall Support                 */
N} const TFTP_CFG;
N
Ntypedef struct tftpc_cfg {        /* << TFTPC Configuration info >>          */
N  U16 BlockSize;                  /* Transfer Block size                     */
N  U16 RetryTout;                  /* Retry Timeout in ticks                  */
N  U8  MaxRetry;                   /* Number of Retries                       */
N} const TFTPC_CFG;
N
Ntypedef struct ftp_cfg {          /* << FTP Configuration info >>            */
N  FTP_INFO *Scb;                  /* Session Control Block array             */
N  U8  NumSess;                    /* Max. Number of Active Sessions          */
N  U8  EnAuth;                     /* Enable User Authentication              */
N  U16 PortNum;                    /* Listening Port number                   */
N  U16 IdleTout;                   /* Idle Connection timeout in ticks        */
N  U8  MsgLen;                     /* Length of welcome message               */
N  U8 const *Msg;                  /* Server Welcome message                  */
N  U8 const *User;                 /* Authentication User Name                */
N  U8 *Passw;                      /* Authentication Password                 */
N} const FTP_CFG;
N
Ntypedef struct ftpc_cfg {         /* << FTPC Configuration info >>           */
N  U8  DefTout;                    /* Default inactivity timeout              */
N  U8  PasvMode;                   /* FTP Passive Mode used                   */
N} const FTPC_CFG;
N
Ntypedef struct dns_cfg {          /* << DNS Configuration info >>            */
N  DNS_CACHE *Table;               /* Cache Table array                       */
N  U8  TabSize;                    /* Cache Table size                        */
N} const DNS_CFG;
N
Ntypedef struct snmp_cfg {         /* << SNMP Configuration info >>           */
N  U16 PortNum;                    /* Listening Port number                   */
N  U16 TrapPort;                   /* Trap Port number                        */
N  U8  TrapIp[IP_ADRLEN];          /* Trap Server IP Address                  */
X  U8  TrapIp[4];
N  U8 const *Community;            /* Community Name                          */
N  U8  TickItv;                    /* Tick Interval in ticks                  */
N} const SNMP_CFG;
N
Ntypedef struct sntp_cfg {         /* << SNTP Configuration info >>           */
N  U8  SrvIp[IP_ADRLEN];           /* NTP/SNTP Server IP Address              */
X  U8  SrvIp[4];
N  U8  Bcast;                      /* Broadcast client mode (for LAN only)    */
N} const SNTP_CFG;
N
Ntypedef struct bsd_cfg {          /* << BSD Configuration info >>            */
N  BSD_INFO *Scb;                  /* Socket Control Block array              */
N  U8  NumSocks;                   /* Number of BSD Sockets                   */
N  U8  InRtx;                      /* Running in RTX environment              */
N  U16 RcvTout;                    /* Blocking recv timeout in ticks          */
N} const BSD_CFG;
N
Ntypedef enum {                    /* << Fatal System Error Codes >>          */
N  ERR_MEM_ALLOC,                  /* Alloc memory failed, out of memory      */
N  ERR_MEM_FREE,                   /* Free memory failed, memory slot invalid */
N  ERR_MEM_CORRUPT,                /* Memory corruption detected              */
N  ERR_MEM_LOCK,                   /* Locked memory function re-entered error */
N  ERR_UDP_ALLOC,                  /* No free UDP sockets available           */
N  ERR_TCP_ALLOC,                  /* No free TCP sockets available           */
N  ERR_TCP_STATE                   /* TCP socket in undefined state           */
N} ERROR_CODE;
N
N
N/*----------------------------------------------------------------------------
N *      Functions
N *---------------------------------------------------------------------------*/
N
N/* Net_Config.c */
Nextern void init_system (void);
Nextern void run_system (void);
Nextern void sys_error (ERROR_CODE code);
N
N/* at_Mem.c */
Nextern OS_FRAME *alloc_mem (U32 byte_size);
Nextern void free_mem (OS_FRAME *mem_ptr);
N
N/* at_Ethernet.c */
Nextern void eth_init_link (void);
Nextern void eth_run_link (void);
Nextern void put_in_queue (OS_FRAME *frame);
Nextern BOOL eth_send_frame (OS_FRAME *frame);
Nextern BOOL eth_chk_adr (OS_FRAME *frame);
Nextern U8  *eth_get_adr (U8 *ipadr);
N
N/* at_Ppp.c */
Nextern void ppp_init_link (void);
Nextern void ppp_run_link (void);
Nextern BOOL ppp_send_frame (OS_FRAME *frame, U16 prot);
N
N/* at_Ppp_Pap.c */
Nextern void pap_init (void);
Nextern void pap_process (OS_FRAME *frame);
Nextern void pap_run (void);
N
N/* at_Ppp_Chap.c */
Nextern void chap_init (void);
Nextern void chap_process (OS_FRAME *frame);
Nextern void chap_run (void);
N
N/* at_Slip.c */
Nextern void slip_init_link (void);
Nextern void slip_run_link (void);
Nextern BOOL slip_send_frame (OS_FRAME *frame);
N
N/* at_Lib.c */
Nextern int  mem_copy (void *dp, void *sp, int len);
Nextern void mem_rcopy (void *dp, void *sp, int len);
Nextern BOOL mem_comp (void *sp1, void *sp2, int len);
Nextern void mem_set (void *dp, U8 val, int len);
Nextern BOOL mem_test (void *sp, U8 val, int len);
Nextern BOOL str_scomp (U8 *sp, U8 const *cp);
Nextern int  str_copy (U8 *dp, U8 *sp);
Nextern void str_up_case (U8 *dp, U8 *sp);
N
N/* at_Arp.c */
Nextern void arp_notify (void);
Nextern BOOL arp_get_info (REMOTEM *info);
N
N/* at_Ip.c */
Nextern void ip_init (void);
Nextern void ip_run_local (void);
N
N/* at_Dhcp.c */
Nextern void dhcp_cbfunc (U8 opt, U8 *val, U16 len);
N
N/* at_Icmp.c */
Nextern void icmp_init (void);
Nextern void icmp_run_engine (void);
N
N/* at_Igmp.c */
Nextern void igmp_init (void);
Nextern void igmp_run_host (void);
Nextern void igmp_process (OS_FRAME *frame);
N
N/* at_Udp.c */
Nextern void udp_init (void);
Nextern void udp_process (OS_FRAME *frame);
N
N/* at_Tcp.c */
Nextern void tcp_init (void);
Nextern void tcp_poll_sockets (void);
Nextern void tcp_process (OS_FRAME *frame);
N
N/* at_Bsd.c */
Nextern void bsd_init (void);
Nextern void bsd_poll_sockets (void);
Nextern U8   bsd_wait (BSD_INFO *bsd_s, U8 evt);
Nextern void bsd_enable (BSD_INFO *bsd_s, U8 evt);
N
N/* at_Bsd_Host.c */
Nextern void bsd_init_host (void);
N
N/* at_Http.c */
Nextern void http_init (void);
Nextern void http_run_server (void);
Nextern void *http_fopen (U8 *name);
Nextern void http_fclose (void *file);
Nextern U16  http_fread (void *file, U8 *buf, U16 len);
Nextern BOOL http_fgets (void *file, U8 *buf, U16 size);
Nextern U32  http_finfo (U8 *name);
Nextern void cgi_process_var (U8 *qstr);
Nextern void cgi_process_data (U8 code, U8 *dat, U16 len);
Nextern U16  cgi_func (U8 *env, U8 *buf, U16 buflen, U32 *pcgi);
Nextern U8  *cgx_content_type (void);
Nextern U8  *http_encoding (void);
Nextern BOOL http_accept_host (U8 *rem_ip, U16 rem_port);
Nextern BOOL http_file_access (U8 *fname, U8 user_id);
Nextern U8   http_check_account (U8 *user, U8 *passw);
Nextern U8  *http_get_var (U8 *env, void *ansi, U16 maxlen);
Nextern U8  *http_get_lang (void);
Nextern void http_get_info (REMOTEM *info);
Nextern U8   http_get_session (void);
Nextern U8   http_get_user_id (void);
Nextern U8  *http_get_content_type (void);
Nextern U32  http_date (RL_TIME *time);
N
N/* at_Telnet.c */
Nextern void tnet_init (void);
Nextern void tnet_run_server (void);
Nextern U16  tnet_cbfunc (U8 code, U8 *buf, U16 buflen);
Nextern U16  tnet_process_cmd (U8 *cmd, U8 *buf, U16 buflen, U32 *pvar);
Nextern BOOL tnet_ccmp (U8 *buf, U8 *cmd);
Nextern void tnet_set_delay (U16 dly);
Nextern void tnet_get_info (REMOTEM *info);
Nextern U8   tnet_get_session (void);
Nextern U8   tnet_get_user_id (void);
Nextern BOOL tnet_msg_poll (U8 session);
Nextern BOOL tnet_accept_host (U8 *rem_ip, U16 rem_port);
Nextern U8   tnet_check_account (U8 code, U8 *id);
N
N/* at_Tftp.c */
Nextern void tftp_init (void);
Nextern void tftp_run_server (void);
Nextern void *tftp_fopen (U8 *fname, U8 *mode);
Nextern void tftp_fclose (void *file);
Nextern U16  tftp_fread (void *file, U8 *buf, U16 len);
Nextern U16  tftp_fwrite (void *file, U8 *buf, U16 len);
Nextern BOOL tftp_accept_host (U8 *rem_ip, U16 rem_port);
N
N/* at_Tftpc.c */
Nextern void tftpc_init (void);
Nextern void tftpc_run_client (void);
Nextern void *tftpc_fopen (U8 *fname, U8 *mode);
Nextern void tftpc_fclose (void *file);
Nextern U16  tftpc_fread (void *file, U8 *buf, U16 len);
Nextern U16  tftpc_fwrite (void *file, U8 *buf, U16 len);
N
N/* at_Ftp.c */
Nextern void ftp_init (void);
Nextern void ftp_run_server (void);
Nextern void *ftp_fopen (U8 *fname, U8 *mode);
Nextern void ftp_fclose (void *file);
Nextern U16  ftp_fread (void *file, U8 *buf, U16 len);
Nextern U16  ftp_fwrite (void *file, U8 *buf, U16 len);
Nextern BOOL ftp_fdelete (U8 *fname);
Nextern BOOL ftp_frename (U8 *fname, U8 *newn);
Nextern U16  ftp_ffind (U8 code, U8 *buf, U8 *mask, U16 len);
Nextern BOOL ftp_accept_host (U8 *rem_ip, U16 rem_port);
Nextern U8   ftp_check_account (U8 code, U8 *id);
Nextern U8   ftp_get_user_id (void);
Nextern BOOL ftp_file_access (U8 *fname, U8 mode, U8 user_id);
Nextern void ftp_evt_notify (U8 evt);
N
N/* at_Ftpc.c */
Nextern void ftpc_init (void);
Nextern void ftpc_run_client (void);
Nextern void *ftpc_fopen (U8 *mode);
Nextern void ftpc_fclose (void *file);
Nextern U16  ftpc_fread (void *file, U8 *buf, U16 len);
Nextern U16  ftpc_fwrite (void *file, U8 *buf, U16 len);
Nextern U16  ftpc_cbfunc (U8 code, U8 *buf, U16 buflen);
N
N/* at_Dhcp.c */
Nextern void dhcp_init (void);
Nextern void dhcp_run_client (void);
N#define init_dhcp   dhcp_init
N
N/* at_Nbns.c */
Nextern void nbns_init (void);
N
N/* at_Dns.c */
Nextern void dns_init (void);
Nextern void dns_run_client (void);
Nextern U8   get_host_by_name (U8 *hostn, void (*cbfunc)(U8, U8 *));
N
N/* at_Smtp.c */
Nextern void smtp_init (void);
Nextern void smtp_run_client (void);
Nextern U16  smtp_cbfunc (U8 code, U8 *buf, U16 buflen, U32 *pvar);
Nextern BOOL smtp_accept_auth (U8 *srv_ip);
N
N/* at_Snmp.c */
Nextern void snmp_init (void);
Nextern void snmp_run_agent (void);
N
N/* at_Sntp.c */
Nextern void sntp_init (void);
Nextern void sntp_run_client (void);
N
N/* Ethernet Device Driver */
Nextern void init_ethernet (void);
Nextern void send_frame (OS_FRAME *frame);
N__weak void poll_ethernet (void);
Nextern void int_enable_eth (void);
Nextern void int_disable_eth (void);
N
N/* Serial Device Driver */
Nextern void init_serial (void);
Nextern int  com_getchar (void);
Nextern BOOL com_putchar (U8 c);
Nextern BOOL com_tx_active (void);
N
N/* Modem Device Driver */
Nextern void modem_init (void);
Nextern void modem_dial (U8 *dialnum);
Nextern void modem_hangup (void);
Nextern void modem_listen (void);
Nextern BOOL modem_online (void);
Nextern BOOL modem_process (U8 ch);
Nextern void modem_run (void);
N
N#ifdef __cplusplus
S}
N#endif
N
N/*----------------------------------------------------------------------------
N * end of file
N *---------------------------------------------------------------------------*/
N
N#endif
N
L 13 "..\..\RL-ARM\Config\Net_Config.c" 2
N
N//-------- <<< Use Configuration Wizard in Context Menu >>> -----------------
N//
N// <h>System Definitions
N// =====================
N// <i> Global TCPnet System definitions
N//   <s.15>Local Host Name
N//   <i> This is the name under which embedded host
N//   <i> can be accessed on a local area network.
N//   <i> Default: "mcb2300"
N#define LHOST_NAME     "armfly"
N
N//   <o>Memory Pool size <1536-262144:4><#/4>
N//   <i> This is the size of a memory pool in bytes. Buffers for
N//   <i> TCPnet packets are allocated from this memory pool.
N//   <i> Default: 8000 bytes
N#define MEM_SIZE       2048
N
N//   <o>Tick Timer interval <10=> 10 ms <20=> 20 ms <25=> 25 ms
N//                          <40=> 40 ms <50=> 50 ms <100=> 100 ms
N//                          <200=> 200 ms
N//   <i> System Tick Timer interval for software timers
N//   <i> Default: 100 ms
N#define TICK_INTERVAL  10
N
N// </h>
N// <e>Ethernet Network Interface
N// =============================
N// <i> Enable or disable Ethernet Network Interface
N#define ETH_ENABLE     1
N
N//   <h>MAC Address
N//   ==============
N//   <i> Local Ethernet MAC Address
N//   <i> Value FF:FF:FF:FF:FF:FF is not allowed.
N//   <i> It is an ethernet Broadcast MAC address.
N//     <o>Address byte 1 <0x00-0xff:2>
N//     <i> LSB is an ethernet Multicast bit.
N//     <i> Must be 0 for local MAC address.
N//     <i> Default: 0x00
N#define _MAC1          0x1E
N
N//     <o>Address byte 2 <0x00-0xff>
N//     <i> Default: 0x30
N#define _MAC2          0x30
N
N//     <o>Address byte 3 <0x00-0xff>
N//     <i> Default: 0x6C
N#define _MAC3          0x6C
N
N//     <o>Address byte 4 <0x00-0xff>
N//     <i> Default: 0x00
N#define _MAC4          0xA2
N
N//     <o>Address byte 5 <0x00-0xff>
N//     <i> Default: 0x00
N#define _MAC5          0x45
N
N//     <o>Address byte 6 <0x00-0xff>
N//     <i> Default: 0x01
N#define _MAC6          0x30
N
N//   </h>
N//   <h>IP Address
N//   =============
N//   <i> Local Static IP Address
N//   <i> Value 255.255.255.255 is not allowed.
N//   <i> It is a Broadcast IP address.
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 192
N#define _IP1           192
N
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 168
N#define _IP2           168
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 0
N#define _IP3           0
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 100
N#define _IP4           30
N
N//   </h>
N//   <h>Subnet mask
N//   ==============
N//   <i> Local Subnet mask
N//     <o>Mask byte 1 <0-255>
N//     <i> Default: 255
N#define _MSK1          255
N
N//     <o>Mask byte 2 <0-255>
N//     <i> Default: 255
N#define _MSK2          255
N
N//     <o>Mask byte 3 <0-255>
N//     <i> Default: 255
N#define _MSK3          255
N
N//     <o>Mask byte 4 <0-255>
N//     <i> Default: 0
N#define _MSK4          0
N
N//   </h>
N//   <h>Default Gateway
N//   ==================
N//   <i> Default Gateway IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 192
N#define _GW1           192
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 168
N#define _GW2           168
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 0
N#define _GW3           0
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 254
N#define _GW4           1
N
N//   </h>
N//   <h>Primary DNS Server
N//   =====================
N//   <i> Primary DNS Server IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 194
N#define _pDNS1         194
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 25
N#define _pDNS2         25
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 2
N#define _pDNS3         2
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 129
N#define _pDNS4         129
N
N//   </h>
N//   <h>Secondary DNS Server
N//   =======================
N//   <i> Secondary DNS Server IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 194
N#define _sDNS1         194
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 25
N#define _sDNS2         25
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 2
N#define _sDNS3         2
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 130
N#define _sDNS4         130
N
N//   </h>
N//   <h>ARP Definitions
N//   ==================
N//   <i> Address Resolution Protocol Definitions
N//     <o>Cache Table size <5-100>
N//     <i> Number of cached hardware/IP addresses
N//     <i> Default: 10
N#define ARP_TABSIZE    10
N
N//     <o>Cache Timeout in seconds <5-255>
N//     <i> A timeout for a cached hardware/IP addresses
N//     <i> Default: 150
N#define ARP_TIMEOUT    150
N
N//     <o>Number of Retries <0-20>
N//     <i> Number of Retries to resolve an IP address
N//     <i> before ARP module gives up
N//     <i> Default: 4
N#define ARP_MAXRETRY   4
N
N//     <o>Resend Timeout in seconds <1-10>
N//     <i> A timeout to resend the ARP Request
N//     <i> Default: 2
N#define ARP_RESEND     2
N
N//     <q>Send Notification on Address changes
N//     <i> When this option is enabled, the embedded host
N//     <i> will send a Gratuitous ARP notification at startup,
N//     <i> or when the device IP address has changed.
N//     <i> Default: Disabled
N#define ARP_NOTIFY     0
N
N//   </h>
N//   <e>IGMP Group Management
N//   ========================
N//   <i> Enable or disable Internet Group Management Protocol
N#define IGMP_ENABLE    0
N
N//     <o>Membership Table size <2-50>
N//     <i> Number of Groups this host can join
N//     <i> Default: 5
N#define IGMP_TABSIZE   5
N
N//   </e>
N//   <q>NetBIOS Name Service
N//   =======================
N//   <i> When this option is enabled, the embedded host can be
N//   <i> accessed by his name on the local LAN using NBNS protocol.
N#define NBNS_ENABLE    1
N
N//   <e>Dynamic Host Configuration
N//   =============================
N//   <i> When this option is enabled, local IP address, Net Mask
N//   <i> and Default Gateway are obtained automatically from
N//   <i> the DHCP Server on local LAN.
N#define DHCP_ENABLE    0
N
N//     <s.40>Vendor Class Identifier
N//     <i> This value is optional. If specified, it is added
N//     <i> to DHCP request message, identifying vendor type.
N//     <i> Default: ""
N#define DHCP_VCID      ""
N
N//     <q>Bootfile Name
N//     <i> This value is optional. If enabled, the Bootfile Name
N//     <i> (option 67) is also requested from DHCP server.
N//     <i> Default: disabled
N#define DHCP_BOOTF     0
N
N//     <q>NTP Servers
N//     <i> This value is optional. If enabled, a list of NTP Servers
N//     <i> (option 42) is also requested from DHCP server.
N//     <i> Default: disabled
N#define DHCP_NTPSRV    0
N
N//   </e>
N// </e>
N
N// <e>PPP Network Interface
N// ========================
N// <i> Enable or disable PPP Network Interface
N#define PPP_ENABLE     0
N
N//   <h>IP Address
N//   =============
N//   <i> Local Static IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 192
N#define _IP1P          192
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 168
N#define _IP2P          168
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 125
N#define _IP3P          125
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 1
N#define _IP4P          1
N
N//   </h>
N//   <h>Subnet mask
N//   ==============
N//   <i> Local Subnet mask
N//     <o>Mask byte 1 <0-255>
N//     <i> Default: 255
N#define _MSK1P         255
N
N//     <o>Mask byte 2 <0-255>
N//     <i> Default: 255
N#define _MSK2P         255
N
N//     <o>Mask byte 3 <0-255>
N//     <i> Default: 255
N#define _MSK3P         255
N
N//     <o>Mask byte 4 <0-255>
N//     <i> Default: 0
N#define _MSK4P         0
N
N//   </h>
N//   <h>Primary DNS Server
N//   =====================
N//   <i> Primary DNS Server IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 194
N#define _pDNS1P        194
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 25
N#define _pDNS2P        25
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 2
N#define _pDNS3P        2
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 129
N#define _pDNS4P        129
N
N//   </h>
N//   <h>Secondary DNS Server
N//   =======================
N//   <i> Secondary DNS Server IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 194
N#define _sDNS1P        194
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 25
N#define _sDNS2P        25
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 2
N#define _sDNS3P        2
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 130
N#define _sDNS4P        130
N
N//   </h>
N//   <e>Logon Authentication
N//   =======================
N//   <i> Enable or disable user authentication
N#define PPP_AUTHEN     1
N
N//     <q>Unsecured password (PAP)
N//     <i>Allow or use Password Authentication Protocol.
N#define PPP_PAPEN      1
N
N//     <q>Secured password (CHAP-MD5)
N//     <i>Request or use Challenge Handshake Authentication
N//     <i>Protocol with MD5 digest algorithm.
N#define PPP_CHAPEN     1
N
N//   </e>
N//   <q>Obtain Client IP address automatically
N//   =========================================
N//   <i> This option only applies when PPP Dial-up is used to dial
N//   <i> to remote PPP Server. If checked, network connection
N//   <i> dynamically obtains an IP address from remote PPP Server.
N#define PPP_GETIP      1
N
N//   <q>Use Default Gateway on remote Network
N//   ========================================
N//   <i> This option only applies when both Ethernet and PPP Dial-up
N//   <i> are used. If checked, data that cannot be sent to local LAN
N//   <i> is forwarded to Dial-up network instead.
N#define PPP_DEFGW      1
N
N//   <o>Async Control Character Map <0x0-0xffffffff>
N//   <i> A bit-map of control characters 0-31, which are
N//   <i> transmitted escaped as a 2 byte sequence.
N//   <i> For XON/XOFF set this value to: 0x000A 0000
N//   <i> Default: 0x00000000
N#define PPP_ACCM       0x00000000
N
N//   <o>LCP Echo Interval in seconds <0-3600>
N//   <i> If no frames are received within this interval, PPP sends an
N//   <i> Echo Request and expects an Echo Response from the peer.
N//   <i> If the response is not received, the link is terminated.
N//   <i> A value of 0 disables the LCP Echo test.
N//   <i> Default: 30
N#define PPP_ECHOTOUT   30
N
N//   <o>Number of Retries <0-20>
N//   <i> How many times PPP will try to retransmit data
N//   <i> before giving up. Increase this value for links
N//   <i> with low baud rates or high latency.
N//   <i> Default: 3
N#define PPP_MAXRETRY   3
N
N//   <o>Retry Timeout in seconds <1-10>
N//   <i> If no response received within this time frame,
N//   <i> PPP module will try to resend the data again.
N//   <i> Default: 2
N#define PPP_RETRYTOUT  2
N
N// </e>
N// <e>SLIP Network Interface
N// ========================
N// <i> Enable or disable SLIP Network Interface
N#define SLIP_ENABLE    0
N
N//   <h>IP Address
N//   =============
N//   <i> Local Static IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 192
N#define _IP1S          192
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 168
N#define _IP2S          168
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 225
N#define _IP3S          225
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 1
N#define _IP4S          1
N
N//   </h>
N//   <h>Subnet mask
N//   ==============
N//   <i> Local Subnet mask
N//     <o>Mask byte 1 <0-255>
N//     <i> Default: 255
N#define _MSK1S         255
N
N//     <o>Mask byte 2 <0-255>
N//     <i> Default: 255
N#define _MSK2S         255
N
N//     <o>Mask byte 3 <0-255>
N//     <i> Default: 255
N#define _MSK3S         255
N
N//     <o>Mask byte 4 <0-255>
N//     <i> Default: 0
N#define _MSK4S         0
N
N//   </h>
N//   <h>Primary DNS Server
N//   =====================
N//   <i> Primary DNS Server IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 194
N#define _pDNS1S        194
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 25
N#define _pDNS2S        25
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 2
N#define _pDNS3S        2
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 129
N#define _pDNS4S        129
N
N//   </h>
N//   <h>Secondary DNS Server
N//   =======================
N//   <i> Secondary DNS Server IP Address
N//     <o>Address byte 1 <0-255>
N//     <i> Default: 194
N#define _sDNS1S        194
N
N//     <o>Address byte 2 <0-255>
N//     <i> Default: 25
N#define _sDNS2S        25
N
N//     <o>Address byte 3 <0-255>
N//     <i> Default: 2
N#define _sDNS3S        2
N
N//     <o>Address byte 4 <0-255>
N//     <i> Default: 130
N#define _sDNS4S        130
N
N//   </h>
N//   <q>Use Default Gateway on remote Network
N//   ========================================
N//   <i> This option only applies when both Ethernet and SLIP Dial-up
N//   <i> are used. If checked, data that cannot be sent to local LAN
N//   <i> is forwarded to Dial-up network instead.
N#define SLIP_DEFGW     1
N
N// </e>
N// <e>UDP Sockets
N// ==============
N// <i> Enable or disable UDP Sockets
N#define UDP_ENABLE     1
N
N//   <o>Number of UDP Sockets <1-20>
N//   <i> Number of available UDP sockets
N//   <i> Default: 5
N#define UDP_NUMSOCKS   5
N
N// </e>
N// <e>TCP Sockets
N// ==============
N// <i> Enable or disable TCP Sockets
N#define TCP_ENABLE     1
N
N//   <o>Number of TCP Sockets <1-20>
N//   <i> Number of available TCP sockets
N//   <i> Default: 5
N#define TCP_NUMSOCKS   5
N
N//   <o>Number of Retries <0-20>
N//   <i> How many times TCP module will try to retransmit data
N//   <i> before giving up. Increase this value for high-latency
N//   <i> and low_throughput networks.
N//   <i> Default: 5
N#define TCP_MAXRETRY   5
N
N//   <o>Retry Timeout in seconds <1-10>
N//   <i> If data frame not acknowledged within this time frame,
N//   <i> TCP module will try to resend the data again.
N//   <i> Default: 4
N#define TCP_RETRYTOUT  4
N
N//   <o>Default Connect Timeout in seconds <1-600>
N//   <i> Default TCP Socket Keep Alive timeout. When it expires
N//   <i> with no TCP data frame send, TCP Connection is closed.
N//   <i> Default: 120
N#define TCP_DEFTOUT    4
N
N//   <o>Maximum Segment Size <536-1460>
N//   <i> The Maximum Segment Size specifies the maximum
N//   <i> number of bytes in the TCP segment's Data field.
N//   <i> Default: 1460
N#define TCP_MAXSEGSZ   1460
N
N//   <o>Receive Window Size <536-65535>
N//   <i> Receive Window Size specifies the size of data,
N//   <i> that the socket is able to buffer in flow-control mode.
N//   <i> Default: 4380
N#define TCP_RECWINSZ   4380
N
N/* TCP fixed timeouts */
N#define TCP_INIT_RETRY_TOUT 1     /* TCP initial Retransmit period in sec.   */
N#define TCP_SYN_RETRY_TOUT  2     /* TCP SYN frame retransmit period in sec. */
N#define TCP_CONRETRY        7     /* Number of retries to establish a conn.  */
N
N// </e>
N// <e>HTTP Server
N// ==============
N// <i> Enable or disable HTTP Server
N#define HTTP_ENABLE    0
N
N//   <o>Number of HTTP Sessions <1-10>
N//   <i> Number of simultaneously active HTTP Sessions.
N//   <i> Default: 3
N#define HTTP_NUMSESS   5
N
N//   <o>Port Number <1-65535>
N//   <i> Listening port number.
N//   <i> Default: 80
N#define HTTP_PORTNUM   80
N
N//   <s.50>Server-Id header
N//   <i> This value is optional. If specified, it overrides
N//   <i> the default HTTP Server header from the library.
N//   <i> Default: ""
N#define HTTP_SRVID     ""
N
N//   <e>Enable User Authentication
N//     <i> When enabled, the user will have to authenticate
N//     <i> himself by username and password before accessing
N//     <i> any page on this Embedded WEB server.
N#define HTTP_ENAUTH    1
N
N//     <s.20>Authentication Realm
N//     <i> Default: "Embedded WEB Server"
N#define HTTP_AUTHREALM "Embedded WEB Server"
N
N//     <s.15>Authentication Username
N//     <i> Default: "admin"
N#define HTTP_AUTHUSER  "admin"
N
N//     <s.15>Authentication Password
N//     <i> Default: ""
N#define HTTP_AUTHPASSW ""
N
N//   </e>
N// </e>
N// <e>Telnet Server
N// ================
N// <i> Enable or disable Telnet Server
N#define TNET_ENABLE    0
N
N//   <o>Number of Telnet Connections <1-10>
N//   <i> Number of simultaneously active Telnet Connections.
N//   <i> Default: 1
N#define TNET_NUMSESS   2
N
N//   <o>Port Number <1-65535>
N//   <i> Listening port number.
N//   <i> Default: 23
N#define TNET_PORTNUM   23
N
N//   <o>Idle Connection Timeout in seconds <0-3600>
N//   <i> When timeout expires, the connection is closed.
N//   <i> A value of 0 disables disconnection on timeout.
N//   <i> Default: 120
N#define TNET_IDLETOUT  120
N
N//   <q>Disable Echo
N//   <i> When disabled, the server will not echo
N//   <i> characters it receives.
N//   <i> Default: Not disabled
N#define TNET_NOECHO    0
N
N//   <e>Enable User Authentication
N//   <i> When enabled, the user will have to authenticate
N//   <i> himself by username and password before access
N//   <i> to the system is allowed.
N#define TNET_ENAUTH    1
N
N//     <s.15>Authentication Username
N//     <i> Default: "admin"
N#define TNET_AUTHUSER  "admin"
N
N//     <s.15>Authentication Password
N//     <i> Default: ""
N#define TNET_AUTHPASSW ""
N
N//   </e>
N// </e>
N// <e>TFTP Server
N// ==============
N// <i> Enable or disable TFTP Server
N#define TFTP_ENABLE    0
N
N//   <o>Number of TFTP Sessions <1-10>
N//   <i> Number of simultaneously active TFTP Sessions
N//   <i> Default: 1
N#define TFTP_NUMSESS   1
N
N//   <o>Port Number <1-65535>
N//   <i> Listening port number.
N//   <i> Default: 69
N#define TFTP_PORTNUM   69
N
N//   <q>Enable Firewall Support
N//   <i> Use the same Port Number to receive
N//   <i> requests and send answers to clients.
N//   <i> Default: Not Enabled
N#define TFTP_ENFWALL   0
N
N//   <o>Inactive Session Timeout in seconds <5-120>
N//   <i> When timeout expires TFTP Session is closed.
N//   <i> Default: 15
N#define TFTP_DEFTOUT   15
N
N//   <o>Number of Retries <1-10>
N//   <i> How many times TFTP Server will try to
N//   <i> retransmit the data before giving up.
N//   <i> Default: 4
N#define TFTP_MAXRETRY  4
N
N// </e>
N// <e>TFTP Client
N// ==============
N// <i> Enable or disable TFTP Client
N#define TFTPC_ENABLE   0
N
N//   <o>Block Size <128=>128   <256=>256   <512=>512
N//                 <1024=>1024 <1428=>1428
N//   <i> Size of transfer block in bytes.
N//   <i> Default: 512
N#define TFTPC_BLOCKSZ  512
N
N//   <o>Number of Retries <1-10>
N//   <i> How many times TFTP Client will try to
N//   <i> retransmit the data before giving up.
N//   <i> Default: 4
N#define TFTPC_MAXRETRY 4
N
N//   <o>Retry Timeout <2=>200 ms <5=>500 ms <10=>1 sec
N//                    <20=>2 sec <50=>5 sec <100=>10 sec
N//   <i> If data frame not acknowledged within this time frame,
N//   <i> TFTP Client will try to resend the data again.
N//   <i> Default: 500 ms
N#define TFTPC_RETRYTO  5
N
N// </e>
N// <e>FTP Server
N// ==============
N// <i> Enable or disable FTP Server
N#define FTP_ENABLE     0
N
N//   <o>Number of FTP Sessions <1-10>
N//   <i> Number of simultaneously active FTP Sessions
N//   <i> Default: 1
N#define FTP_NUMSESS    3
N
N//   <o>Port Number <1-65535>
N//   <i> Listening port number.
N//   <i> Default: 21
N#define FTP_PORTNUM    21
N
N//   <s.50>Welcome Message
N//   <i> This value is optional. If specified,
N//   <i> it overrides the default welcome message.
N//   <i> Default: ""
N#define FTP_WELMSG     ""
N
N//   <o>Idle Session Timeout in seconds <0-3600>
N//   <i> When timeout expires, the connection is closed.
N//   <i> A value of 0 disables disconnection on timeout.
N//   <i> Default: 120
N#define FTP_IDLETOUT   120
N
N//   <e>Enable User Authentication
N//   <i> When enabled, the user will have to authenticate
N//   <i> himself by username and password before access
N//   <i> to the system is allowed.
N#define FTP_ENAUTH     1
N
N//     <s.15>Authentication Username
N//     <i> Default: "admin"
N#define FTP_AUTHUSER   "admin"
N
N//     <s.15>Authentication Password
N//     <i> Default: ""
N#define FTP_AUTHPASSW  ""
N
N//   </e>
N// </e>
N// <e>FTP Client
N// =============
N// <i> Enable or disable FTP Client
N#define FTPC_ENABLE    0
N
N//     <o>Response Timeout in seconds <1-120>
N//     <i> This is a time for FTP Client to wait for a response from
N//     <i> the Server. If timeout expires, Client aborts operation.
N//     <i> Default: 10
N#define FTPC_DEFTOUT   10
N
N//     <q>Passive mode (PASV)
N//     <i> The client initiates a data connection to the server.
N//     <i> Default: Not passive (Active)
N#define FTPC_PASVMODE  0
N
N// </e>
N// <e>DNS Client
N// =============
N// <i> Enable or disable DNS Client
N#define DNS_ENABLE     0
N
N//     <o>Cache Table size <5-100>
N//     <i> Number of cached DNS host names/IP addresses
N//     <i> Default: 20
N#define DNS_TABSIZE    20
N
N// </e>
N// <e>SMTP Client
N// ==============
N// <i> Enable or disable SMTP Client
N#define SMTP_ENABLE    0
N
N//     <o>Response Timeout in seconds <5-120>
N//     <i> This is a time for SMTP Client to wait for a response from
N//     <i> SMTP Server. If timeout expires, Client aborts operation.
N//     <i> Default: 20
N#define SMTP_DEFTOUT   20
N
N// </e>
N// <e>SNMP Agent
N// =============
N// <i> Enable or disable SNMP Agent
N#define SNMP_ENABLE    0
N
N//   <s.15>Community Name
N//   <i> Defines where an SNMP message is destined for.
N//   <i> Default: "public"
N#define SNMP_COMMUNITY "public"
N
N//   <o>Port Number <1-65535>
N//   <i> Listening port number.
N//   <i> Default: 161
N#define SNMP_PORTNUM   161
N
N//   <o>Trap Port Number <1-65535>
N//   <i> Port number for Trap operations.
N//   <i> Default: 162
N#define SNMP_TRAPPORT  162
N
N//   <h>Trap Server
N//   ==============
N//   <i> Trap Server IP Address
N//   <o>Address byte 1 <0-255>
N//   <i> Default: 192
N#define SNMP_TRAPIP1   192
N
N//   <o>Address byte 2 <0-255>
N//   <i> Default: 168
N#define SNMP_TRAPIP2   168
N
N//   <o>Address byte 3 <0-255>
N//   <i> Default: 0
N#define SNMP_TRAPIP3   0
N
N//   <o>Address byte 4 <0-255>
N//   <i> Default: 100
N#define SNMP_TRAPIP4   1
N
N//   </h>
N// </e>
N// <e>SNTP Client
N// ==============
N// <i> Enable or disable SNTP Client
N#define SNTP_ENABLE    0
N
N//   <q>Broadcast Mode
N//   =================
N//   <i> Enable this option, if you have NTP/SNTP server
N//   <i> on LAN, which is broadcasting NTP time messages.
N//   <i> Disable this option to access public NTP server.
N//   <i> Default: disabled
N#define SNTP_BCMODE    0
N
N//   <h>NTP Server
N//   =============
N//   <i> Server IP Address
N//   <o>Address byte 1 <0-255>
N//   <i> Default: 217
N#define SNTP_SRVIP1    217
N
N//   <o>Address byte 2 <0-255>
N//   <i> Default: 79
N#define SNTP_SRVIP2    79
N
N//   <o>Address byte 3 <0-255>
N//   <i> Default: 179
N#define SNTP_SRVIP3    179
N
N//   <o>Address byte 4 <0-255>
N//   <i> Default: 106
N#define SNTP_SRVIP4    106
N
N//   </h>
N// </e>
N// <e>BSD Socket Interface
N// =======================
N// <i> Enable or disable Berkeley Socket Programming Interface
N#define BSD_ENABLE     1
N
N//   <o>Number of BSD Sockets <1-20>
N//   <i> Number of available Berkeley Sockets
N//   <i> Default: 2
N#define BSD_NUMSOCKS   2
N
N//   <o>Number of Streaming Server Sockets <0-20>
N//   <i> Defines a number of Streaming (TCP) Server sockets,
N//   <i> that listen for an incoming connection from the client.
N//   <i> Default: 1
N#define BSD_SRVSOCKS   1
N
N//   <o>Receive Timeout in seconds <0-600>
N//   <i> A timeout for socket receive in blocking mode.
N//   <i> Timeout value of 0 means indefinite timeout.
N//   <i> Default: 20
N#define BSD_RCVTOUT    20
N
N//   <q>Hostname Resolver
N//   <i> Enable or disable Berkeley style hostname resolver.
N#define BSD_GETHOSTEN  0
N
N// </e>
N//------------- <<< end of configuration section >>> -----------------------
N
N/*----------------------------------------------------------------------------
N *      Fatal Error Handler
N *---------------------------------------------------------------------------*/
N
Nvoid sys_error (ERROR_CODE code) {
N  /* This function is called when a fatal error is encountered. The normal */
N  /* program execution is not possible anymore. Add your crytical error   .*/
N  /* handler code here.                                                    */
N
N  switch (code)
N	{
N    case ERR_MEM_ALLOC:
N      /* Out of memory. */
N      break;
N
N    case ERR_MEM_FREE:
N      /* Trying to release non existing memory block. */
N      break;
N
N    case ERR_MEM_CORRUPT:
N      /* Memory Link pointer is Corrupted. */
N      /* More data written than the size of allocated mem block. */
N      break;
N
N    case ERR_MEM_LOCK:
N      /* Locked Memory management function (alloc/free) re-entered. */
N      /* RTX multithread protection malfunctioning, not implemented */
N      /* or interrupt disable is not functioning correctly. */
N      break;
N
N    case ERR_UDP_ALLOC:
N      /* Out of UDP Sockets. */
N      break;
N
N    case ERR_TCP_ALLOC:
N      /* Out of TCP Sockets. */
N      break;
N
N    case ERR_TCP_STATE:
N      /* TCP State machine in undefined state. */
N      break;
N	}
N
N  /* End-less loop */
N  while (1);
N}
N
N/*----------------------------------------------------------------------------
N *      TCPnet Config Functions
N *---------------------------------------------------------------------------*/
N
N#define  __NET_CONFIG__
N
N#include <Net_lib.c>
L 1 "..\..\RL-ARM\Config\Net_lib.c" 1
N/*----------------------------------------------------------------------------
N *      RL-ARM - TCPnet
N *----------------------------------------------------------------------------
N *      Name:    NET_LIB.C
N *      Purpose: TCPnet System Configuration
N *      Rev.:    V4.72
N *----------------------------------------------------------------------------
N *      This code is part of the RealView Run-Time Library.
N *      Copyright (c) 2004-2013 KEIL - An ARM Company. All rights reserved.
N *---------------------------------------------------------------------------*/
N
N#pragma thumb
N#pragma O3
N
N/*----------------------------------------------------------------------------
N *      Library for Net_Config.c
N *---------------------------------------------------------------------------*/
N
N#ifdef __NET_CONFIG__
N
N#if (__RTX)
X#if (1)
N  #include "os.h"
L 1 "..\..\uCOS-III\uCOS-III\Source\os.h" 1
N/*
N************************************************************************************************************************
N*                                                      uC/OS-III
N*                                                 The Real-Time Kernel
N*
N*                                  (c) Copyright 2009-2012; Micrium, Inc.; Weston, FL
N*                           All rights reserved.  Protected by international copyright laws.
N*
N* File    : OS.H
N* By      : JJL
N* Version : V3.03.01
N*
N* LICENSING TERMS:
N* ---------------
N*           uC/OS-III is provided in source form for FREE short-term evaluation, for educational use or
N*           for peaceful research.  If you plan or intend to use uC/OS-III in a commercial application/
N*           product then, you need to contact Micrium to properly license uC/OS-III for its use in your
N*           application/product.   We provide ALL the source code for your convenience and to help you
N*           experience uC/OS-III.  The fact that the source is provided does NOT mean that you can use
N*           it commercially without paying a licensing fee.
N*
N*           Knowledge of 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 software available.
N*           Your honesty is greatly appreciated.
N*
N*           You can contact us at www.micrium.com, or by phone at +1 (954) 217-2036.
N************************************************************************************************************************
N* Note(s) : (1) Assumes the following versions (or more recent) of software modules are included in the project build:
N*
N*               (a) uC/LIB V1.36.01
N*               (b) uC/CPU V1.29.00
N************************************************************************************************************************
N*/
N
N#ifndef   OS_H
N#define   OS_H
N
N/*
N************************************************************************************************************************
N*                                               uC/OS-III VERSION NUMBER
N************************************************************************************************************************
N*/
N
N#define  OS_VERSION  30301u                       /* Version of uC/OS-III (Vx.yy.zz mult. by 10000)                   */
N
N/*
N************************************************************************************************************************
N*                                                 INCLUDE HEADER FILES
N************************************************************************************************************************
N*/
N
N#ifdef __cplusplus
Sextern "C" {
N#endif
N
N
N
N#include <os_cfg.h>
L 1 "..\..\User\os_cfg.h" 1
N/*
N************************************************************************************************************************
N*                                                      uC/OS-III
N*                                                 The Real-Time Kernel
N*
N*                                  (c) Copyright 2009-2011; Micrium, Inc.; Weston, FL
N*                           All rights reserved.  Protected by international copyright laws.
N*
N*                                                  CONFIGURATION FILE
N*
N* File    : OS_CFG.H
N* By      : JJL
N* Version : V3.02.00
N*
N* LICENSING TERMS:
N* ---------------
N*           uC/OS-III is provided in source form for FREE short-term evaluation, for educational use or
N*           for peaceful research.  If you plan or intend to use uC/OS-III in a commercial application/
N*           product then, you need to contact Micrium to properly license uC/OS-III for its use in your
N*           application/product.   We provide ALL the source code for your convenience and to help you
N*           experience uC/OS-III.  The fact that the source is provided does NOT mean that you can use
N*           it commercially without paying a licensing fee.
N*
N*           Knowledge of 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 software available.
N*           Your honesty is greatly appreciated.
N*
N*           You can contact us at www.micrium.com, or by phone at +1 (954) 217-2036.
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_H
N#define OS_CFG_H
N
N
N                                             /* ---------------------------- MISCELLANEOUS -------------------------- */
N#define OS_CFG_APP_HOOKS_EN             1u   /* Enable (1) or Disable (0) application specific hooks                  */
N#define OS_CFG_ARG_CHK_EN               1u   /* Enable (1) or Disable (0) argument checking                           */
N#define OS_CFG_CALLED_FROM_ISR_CHK_EN   1u   /* Enable (1) or Disable (0) check for called from ISR                   */
N#define OS_CFG_DBG_EN                   1u   /* Enable (1) debug code/variables                                       */
N#define OS_CFG_ISR_POST_DEFERRED_EN     0u   /* Enable (1) or Disable (0) Deferred ISR posts                          */
N#define OS_CFG_OBJ_TYPE_CHK_EN          1u   /* Enable (1) or Disable (0) object type checking                        */
N#define OS_CFG_TS_EN                    1u   /* Enable (1) or Disable (0) time stamping                               */
N
N#define OS_CFG_PEND_MULTI_EN            1u   /* Enable (1) or Disable (0) code generation for multi-pend feature      */
N
N#define OS_CFG_PRIO_MAX                64u   /* Defines the maximum number of task priorities (see OS_PRIO data type) */
N
N#define OS_CFG_SCHED_LOCK_TIME_MEAS_EN  0u   /* Include code to measure scheduler lock time                           */
N#define OS_CFG_SCHED_ROUND_ROBIN_EN     0u   /* Include code for Round-Robin scheduling                               */
N#define OS_CFG_STK_SIZE_MIN            64u   /* Minimum allowable task stack size                                     */
N
N
N                                             /* ----------------------------- EVENT FLAGS --------------------------- */
N#define OS_CFG_FLAG_EN                  1u   /* Enable (1) or Disable (0) code generation for EVENT FLAGS             */
N#define OS_CFG_FLAG_DEL_EN              1u   /*     Include code for OSFlagDel()                                      */
N#define OS_CFG_FLAG_MODE_CLR_EN         1u   /*     Include code for Wait on Clear EVENT FLAGS                        */
N#define OS_CFG_FLAG_PEND_ABORT_EN       1u   /*     Include code for OSFlagPendAbort()                                */
N
N
N                                             /* -------------------------- MEMORY MANAGEMENT ------------------------ */
N#define OS_CFG_MEM_EN                   1u   /* Enable (1) or Disable (0) code generation for MEMORY MANAGER          */
N
N
N                                             /* --------------------- MUTUAL EXCLUSION SEMAPHORES ------------------- */
N#define OS_CFG_MUTEX_EN                 1u   /* Enable (1) or Disable (0) code generation for MUTEX                   */
N#define OS_CFG_MUTEX_DEL_EN             1u   /*     Include code for OSMutexDel()                                     */
N#define OS_CFG_MUTEX_PEND_ABORT_EN      1u   /*     Include code for OSMutexPendAbort()                               */
N
N
N                                             /* --------------------------- MESSAGE QUEUES -------------------------- */
N#define OS_CFG_Q_EN                     1u   /* Enable (1) or Disable (0) code generation for QUEUES                  */
N#define OS_CFG_Q_DEL_EN                 1u   /*     Include code for OSQDel()                                         */
N#define OS_CFG_Q_FLUSH_EN               1u   /*     Include code for OSQFlush()                                       */
N#define OS_CFG_Q_PEND_ABORT_EN          1u   /*     Include code for OSQPendAbort()                                   */
N
N
N                                             /* ----------------------------- SEMAPHORES ---------------------------- */
N#define OS_CFG_SEM_EN                   1u   /* Enable (1) or Disable (0) code generation for SEMAPHORES              */
N#define OS_CFG_SEM_DEL_EN               1u   /*    Include code for OSSemDel()                                        */
N#define OS_CFG_SEM_PEND_ABORT_EN        1u   /*    Include code for OSSemPendAbort()                                  */
N#define OS_CFG_SEM_SET_EN               1u   /*    Include code for OSSemSet()                                        */
N
N
N                                             /* -------------------------- TASK MANAGEMENT -------------------------- */
N#define OS_CFG_STAT_TASK_EN             0u   /* Enable (1) or Disable(0) the statistics task                          */
N#define OS_CFG_STAT_TASK_STK_CHK_EN     1u   /* Check task stacks from statistic task                                 */
N
N#define OS_CFG_TASK_CHANGE_PRIO_EN      1u   /* Include code for OSTaskChangePrio()                                   */
N#define OS_CFG_TASK_DEL_EN              1u   /* Include code for OSTaskDel()                                          */
N#define OS_CFG_TASK_Q_EN                1u   /* Include code for OSTaskQXXXX()                                        */
N#define OS_CFG_TASK_Q_PEND_ABORT_EN     1u   /* Include code for OSTaskQPendAbort()                                   */
N#define OS_CFG_TASK_PROFILE_EN          1u   /* Include variables in OS_TCB for profiling                             */
N#define OS_CFG_TASK_REG_TBL_SIZE        1u   /* Number of task specific registers                                     */
N#define OS_CFG_TASK_SEM_PEND_ABORT_EN   1u   /* Include code for OSTaskSemPendAbort()                                 */
N#define OS_CFG_TASK_SUSPEND_EN          1u   /* Include code for OSTaskSuspend() and OSTaskResume()                   */
N
N
N                                             /* -------------------------- TIME MANAGEMENT -------------------------- */
N#define OS_CFG_TIME_DLY_HMSM_EN         1u   /*     Include code for OSTimeDlyHMSM()                                  */
N#define OS_CFG_TIME_DLY_RESUME_EN       1u   /*     Include code for OSTimeDlyResume()                                */
N
N
N                                             /* ------------------------- TIMER MANAGEMENT -------------------------- */
N#define OS_CFG_TMR_EN                   1u   /* Enable (1) or Disable (0) code generation for TIMERS                  */
N#define OS_CFG_TMR_DEL_EN               1u   /* Enable (1) or Disable (0) code generation for OSTmrDel()              */
N
N#endif
L 60 "..\..\uCOS-III\uCOS-III\Source\os.h" 2
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 61 "..\..\uCOS-III\uCOS-III\Source\os.h" 2
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>
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 62 "..\..\uCOS-III\uCOS-III\Source\os.h" 2
N#include <lib_def.h>
N#include <os_type.h>
L 1 "..\..\uCOS-III\uCOS-III\Source\os_type.h" 1
N/*
N************************************************************************************************************************
N*                                                      uC/OS-III
N*                                                 The Real-Time Kernel
N*
N*                                  (c) Copyright 2009-2012; Micrium, Inc.; Weston, FL
N*                           All rights reserved.  Protected by international copyright laws.
N*
N* File    : OS_TYPE.H
N* By      : JJL
N* Version : V3.03.01
N*
N* LICENSING TERMS:
N* ---------------
N*           uC/OS-III is provided in source form for FREE short-term evaluation, for educational use or
N*           for peaceful research.  If you plan or intend to use uC/OS-III in a commercial application/
N*           product then, you need to contact Micrium to properly license uC/OS-III for its use in your
N*           application/product.   We provide ALL the source code for your convenience and to help you
N*           experience uC/OS-III.  The fact that the source is provided does NOT mean that you can use
N*           it commercially without paying a licensing fee.
N*
N*           Knowledge of 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 software available.
N*           Your honesty is greatly appreciated.
N*
N*           You can contact us at www.micrium.com, or by phone at +1 (954) 217-2036.
N************************************************************************************************************************
N*/
N
N#ifndef   OS_TYPE_H
N#define   OS_TYPE_H
N
N#ifdef    VSC_INCLUDE_H_FILE_NAMES
Sconst     CPU_CHAR  *os_type__h = "$Id: $";
N#endif
N
N/*
N************************************************************************************************************************
N*                                                 INCLUDE HEADER FILES
N************************************************************************************************************************
N*/
N
N                                                       /*       Description                                    # Bits */
N                                                       /*                                               <recommended> */
N                                                       /* ----------------------------------------------------------- */
N
Ntypedef   CPU_INT16U      OS_CPU_USAGE;                /* CPU Usage 0..10000                                  <16>/32 */
N
Ntypedef   CPU_INT32U      OS_CTR;                      /* Counter,                                                 32 */
N
Ntypedef   CPU_INT32U      OS_CTX_SW_CTR;               /* Counter of context switches,                             32 */
N
Ntypedef   CPU_INT32U      OS_CYCLES;                   /* CPU clock cycles,                                   <32>/64 */
N
Ntypedef   CPU_INT32U      OS_FLAGS;                    /* Event flags,                                      8/16/<32> */
N
Ntypedef   CPU_INT32U      OS_IDLE_CTR;                 /* Holds the number of times the idle task runs,       <32>/64 */
N
Ntypedef   CPU_INT16U      OS_MEM_QTY;                  /* Number of memory blocks,                            <16>/32 */
Ntypedef   CPU_INT16U      OS_MEM_SIZE;                 /* Size in bytes of a memory block,                    <16>/32 */
N
Ntypedef   CPU_INT16U      OS_MSG_QTY;                  /* Number of OS_MSGs in the msg pool,                  <16>/32 */
Ntypedef   CPU_INT16U      OS_MSG_SIZE;                 /* Size of messages in number of bytes,                <16>/32 */
N
Ntypedef   CPU_INT08U      OS_NESTING_CTR;              /* Interrupt and scheduler nesting,                  <8>/16/32 */
N
Ntypedef   CPU_INT16U      OS_OBJ_QTY;                  /* Number of kernel objects counter,                   <16>/32 */
Ntypedef   CPU_INT32U      OS_OBJ_TYPE;                 /* Special flag to determine object type,                   32 */
N
Ntypedef   CPU_INT16U      OS_OPT;                      /* Holds function options                              <16>/32 */
N
Ntypedef   CPU_INT08U      OS_PRIO;                     /* Priority of a task,                               <8>/16/32 */
N
Ntypedef   CPU_INT16U      OS_QTY;                      /* Quantity                                            <16>/32 */
N
Ntypedef   CPU_INT32U      OS_RATE_HZ;                  /* Rate in Hertz                                            32 */
N
Ntypedef   CPU_INT32U      OS_REG;                      /* Task register                                     8/16/<32> */
Ntypedef   CPU_INT08U      OS_REG_ID;                   /* Index to task register                            <8>/16/32 */
N
Ntypedef   CPU_INT32U      OS_SEM_CTR;                  /* Semaphore value                                     16/<32> */
N
Ntypedef   CPU_INT08U      OS_STATE;                    /* State variable                                    <8>/16/32 */
N
Ntypedef   CPU_INT08U      OS_STATUS;                   /* Status                                            <8>/16/32 */
N
Ntypedef   CPU_INT32U      OS_TICK;                     /* Clock tick counter                                  <32>/64 */
Ntypedef   CPU_INT16U      OS_TICK_SPOKE_IX;            /* Tick wheel spoke position                         8/<16>/32 */
N
Ntypedef   CPU_INT16U      OS_TMR_SPOKE_IX;             /* Timer wheel spoke position                        8/<16>/32 */
N
N#endif
L 64 "..\..\uCOS-III\uCOS-III\Source\os.h" 2
N#include <os_cpu.h>
L 1 "..\..\uCOS-III\uCOS-III\Ports\ARM-Cortex-M4\Generic\RealView\os_cpu.h" 1
N/*
N*********************************************************************************************************
N*                                                uC/OS-III
N*                                          The Real-Time Kernel
N*
N*
N*                              (c) Copyright 2010; Micrium, Inc.; Weston, FL
N*                    All rights reserved.  Protected by international copyright laws.
N*
N*                                           ARM Cortex-M4 Port
N*
N* File      : OS_CPU.H
N* Version   : V3.01.2
N* By        : JJL
N*
N* LICENSING TERMS:
N* ---------------
N*           uC/OS-III is provided in source form for FREE short-term evaluation, for educational use or
N*           for peaceful research.  If you plan or intend to use uC/OS-III in a commercial application/
N*           product then, you need to contact Micrium to properly license uC/OS-III for its use in your
N*           application/product.   We provide ALL the source code for your convenience and to help you
N*           experience uC/OS-III.  The fact that the source is provided does NOT mean that you can use
N*           it commercially without paying a licensing fee.
N*
N*           Knowledge of 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 software available.
N*           Your honesty is greatly appreciated.
N*
N*           You can contact us at www.micrium.com, or by phone at +1 (954) 217-2036.
N*
N* For       : ARMv7 Cortex-M4
N* Mode      : Thumb-2 ISA
N* Toolchain : RealView
N*********************************************************************************************************
N*/
N
N#ifndef  OS_CPU_H
N#define  OS_CPU_H
N
N#ifdef   OS_CPU_GLOBALS
S#define  OS_CPU_EXT
N#else
N#define  OS_CPU_EXT  extern
N#endif
N
N/*
N*********************************************************************************************************
N*                                               DEFINES
N*********************************************************************************************************
N*/
N
N// #ifdef __ARMVFP__
N
N// #else
N// #define  OS_CPU_ARM_FP_EN                              DEF_DISABLED
N// #endif
N// #define  OS_CPU_ARM_FP_REG_NBR                           32u
N#define  OS_CPU_ARM_FP_EN                              DEF_ENABLED
N/*
N*********************************************************************************************************
N*                                               MACROS
N*********************************************************************************************************
N*/
N
N#define  OS_TASK_SW()               OSCtxSw()
N
N/*
N*********************************************************************************************************
N*                                       TIMESTAMP CONFIGURATION
N*
N* Note(s) : (1) OS_TS_GET() is generally defined as CPU_TS_Get32() to allow CPU timestamp timer to be of
N*               any data type size.
N*
N*           (2) For architectures that provide 32-bit or higher precision free running counters
N*               (i.e. cycle count registers):
N*
N*               (a) OS_TS_GET() may be defined as CPU_TS_TmrRd() to improve performance when retrieving
N*                   the timestamp.
N*
N*               (b) CPU_TS_TmrRd() MUST be configured to be greater or equal to 32-bits to avoid
N*                   truncation of TS.
N*********************************************************************************************************
N*/
N
N#if      OS_CFG_TS_EN == 1u
X#if      1u == 1u
N#define  OS_TS_GET()               (CPU_TS)CPU_TS_TmrRd()   /* See Note #2a.                                          */
N#else
S#define  OS_TS_GET()               (CPU_TS)0u
N#endif
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)
S                                                            /* CPU_CFG_TS_TMR_SIZE MUST be >= 32-bit (see Note #2b).  */
S#error  "cpu_cfg.h, CPU_CFG_TS_TMR_SIZE MUST be >= CPU_WORD_SIZE_32"
N#endif
N
N
N/*
N*********************************************************************************************************
N*                              OS TICK INTERRUPT PRIORITY CONFIGURATION
N*
N* Note(s) : (1) For systems that don't need any high, real-time priority interrupts; the tick interrupt
N*               should be configured as the highest priority interrupt but won't adversely affect system
N*               operations.
N*
N*           (2) For systems that need one or more high, real-time interrupts; these should be configured
N*               higher than the tick interrupt which MAY delay execution of the tick interrupt.
N*
N*               (a) If the higher priority interrupts do NOT continually consume CPU cycles but only
N*                   occasionally delay tick interrupts, then the real-time interrupts can successfully
N*                   handle their intermittent/periodic events with the system not losing tick interrupts
N*                   but only increasing the jitter.
N*
N*               (b) If the higher priority interrupts consume enough CPU cycles to continually delay the
N*                   tick interrupt, then the CPU/system is most likely over-burdened & can't be expected
N*                   to handle all its interrupts/tasks. The system time reference gets compromised as a
N*                   result of losing tick interrupts.
N*********************************************************************************************************
N*/
N
N#define  OS_CPU_CFG_SYSTICK_PRIO           0u
N
N/*
N*********************************************************************************************************
N*                                          GLOBAL VARIABLES
N*********************************************************************************************************
N*/
N
NOS_CPU_EXT  CPU_STK  *OS_CPU_ExceptStkBase;
Xextern  CPU_STK  *OS_CPU_ExceptStkBase;
N
N/*
N*********************************************************************************************************
N*                                         FUNCTION PROTOTYPES
N*********************************************************************************************************
N*/
N
Nvoid  OSCtxSw              (void);
Nvoid  OSIntCtxSw           (void);
Nvoid  OSStartHighRdy       (void);
N
Nvoid  OS_CPU_PendSVHandler (void);
N
N
Nvoid  OS_CPU_SysTickHandler(void);
Nvoid  OS_CPU_SysTickInit   (CPU_INT32U  cnts);
N
N//#if (OS_CPU_ARM_FP_EN == DEF_ENABLED)
Nvoid  OS_CPU_FP_Reg_Push   (CPU_STK    *stkPtr);
Nvoid  OS_CPU_FP_Reg_Pop    (CPU_STK    *stkPtr);
N//#endif
N#endif
L 65 "..\..\uCOS-III\uCOS-III\Source\os.h" 2
N
N
N/*
N************************************************************************************************************************
N*                                               CRITICAL SECTION HANDLING
N************************************************************************************************************************
N*/
N
N
N#if      OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u && defined(CPU_CFG_INT_DIS_MEAS_EN)
X#if      0u > 0u && 0L
S#define  OS_SCHED_LOCK_TIME_MEAS_START()    OS_SchedLockTimeMeasStart()
N#else
N#define  OS_SCHED_LOCK_TIME_MEAS_START()
N#endif
N
N
N#if      OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u && defined(CPU_CFG_INT_DIS_MEAS_EN)
X#if      0u > 0u && 0L
S#define  OS_SCHED_LOCK_TIME_MEAS_STOP()     OS_SchedLockTimeMeasStop()
N#else
N#define  OS_SCHED_LOCK_TIME_MEAS_STOP()
N#endif
N
N#if OS_CFG_ISR_POST_DEFERRED_EN > 0u                             /* Deferred ISR Posts ------------------------------ */
X#if 0u > 0u
S                                                                 /* Lock the scheduler                                */
S#define  OS_CRITICAL_ENTER()                                       \
S         do {                                                      \
S             CPU_CRITICAL_ENTER();                                 \
S             OSSchedLockNestingCtr++;                              \
S             if (OSSchedLockNestingCtr == 1u) {                    \
S                 OS_SCHED_LOCK_TIME_MEAS_START();                  \
S             }                                                     \
S             CPU_CRITICAL_EXIT();                                  \
S         } while (0)
X#define  OS_CRITICAL_ENTER()                                                do {                                                                   CPU_CRITICAL_ENTER();                                              OSSchedLockNestingCtr++;                                           if (OSSchedLockNestingCtr == 1u) {                                     OS_SCHED_LOCK_TIME_MEAS_START();                               }                                                                  CPU_CRITICAL_EXIT();                                           } while (0)
S                                                                 /* Lock the scheduler but re-enable interrupts       */
S#define  OS_CRITICAL_ENTER_CPU_EXIT()                              \
S         do {                                                      \
S             OSSchedLockNestingCtr++;                              \
S                                                                   \
S             if (OSSchedLockNestingCtr == 1u) {                    \
S                 OS_SCHED_LOCK_TIME_MEAS_START();                  \
S             }                                                     \
S             CPU_CRITICAL_EXIT();                                  \
S         } while (0)
X#define  OS_CRITICAL_ENTER_CPU_EXIT()                                       do {                                                                   OSSchedLockNestingCtr++;                                                                                                              if (OSSchedLockNestingCtr == 1u) {                                     OS_SCHED_LOCK_TIME_MEAS_START();                               }                                                                  CPU_CRITICAL_EXIT();                                           } while (0)
S
S                                                                 /* Scheduling occurs only if an interrupt occurs     */
S#define  OS_CRITICAL_EXIT()                                        \
S         do {                                                      \
S             CPU_CRITICAL_ENTER();                                 \
S             OSSchedLockNestingCtr--;                              \
S             if (OSSchedLockNestingCtr == (OS_NESTING_CTR)0) {     \
S                 OS_SCHED_LOCK_TIME_MEAS_STOP();                   \
S                 if (OSIntQNbrEntries > (OS_OBJ_QTY)0) {           \
S                     CPU_CRITICAL_EXIT();                          \
S                     OS_Sched0();                                  \
S                 } else {                                          \
S                     CPU_CRITICAL_EXIT();                          \
S                 }                                                 \
S             } else {                                              \
S                 CPU_CRITICAL_EXIT();                              \
S             }                                                     \
S         } while (0)
X#define  OS_CRITICAL_EXIT()                                                 do {                                                                   CPU_CRITICAL_ENTER();                                              OSSchedLockNestingCtr--;                                           if (OSSchedLockNestingCtr == (OS_NESTING_CTR)0) {                      OS_SCHED_LOCK_TIME_MEAS_STOP();                                    if (OSIntQNbrEntries > (OS_OBJ_QTY)0) {                                CPU_CRITICAL_EXIT();                                               OS_Sched0();                                                   } else {                                                               CPU_CRITICAL_EXIT();                                           }                                                              } else {                                                               CPU_CRITICAL_EXIT();                                           }                                                              } while (0)
S
S#define  OS_CRITICAL_EXIT_NO_SCHED()                               \
S         do {                                                      \
S             CPU_CRITICAL_ENTER();                                 \
S             OSSchedLockNestingCtr--;                              \
S             if (OSSchedLockNestingCtr == (OS_NESTING_CTR)0) {     \
S                 OS_SCHED_LOCK_TIME_MEAS_STOP();                   \
S             }                                                     \
S             CPU_CRITICAL_EXIT();                                  \
S         } while (0)
X#define  OS_CRITICAL_EXIT_NO_SCHED()                                        do {                                                                   CPU_CRITICAL_ENTER();                                              OSSchedLockNestingCtr--;                                           if (OSSchedLockNestingCtr == (OS_NESTING_CTR)0) {                      OS_SCHED_LOCK_TIME_MEAS_STOP();                                }                                                                  CPU_CRITICAL_EXIT();                                           } while (0)
S
S
N#else                                                            /* Direct ISR Posts -------------------------------- */
N
N
N#define  OS_CRITICAL_ENTER()                    CPU_CRITICAL_ENTER()
N
N#define  OS_CRITICAL_ENTER_CPU_EXIT()
N
N#define  OS_CRITICAL_EXIT()                     CPU_CRITICAL_EXIT()
N
N#define  OS_CRITICAL_EXIT_NO_SCHED()            CPU_CRITICAL_EXIT()
N
N#endif
N
N/*
N************************************************************************************************************************
N*                                                     MISCELLANEOUS
N************************************************************************************************************************
N*/
N
N#ifdef   OS_GLOBALS
S#define  OS_EXT
N#else
N#define  OS_EXT  extern
N#endif
N
N
N#define  OS_PRIO_TBL_SIZE          ((OS_CFG_PRIO_MAX - 1u) / (DEF_INT_CPU_NBR_BITS) + 1u)
N
N#define  OS_MSG_EN                 (((OS_CFG_TASK_Q_EN > 0u) || (OS_CFG_Q_EN > 0u)) ? 1u : 0u)
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                                                   # D E F I N E S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
N/*
N========================================================================================================================
N*                                                      TASK STATUS
N========================================================================================================================
N*/
N
N#define  OS_STATE_OS_STOPPED                    (OS_STATE)(0u)
N#define  OS_STATE_OS_RUNNING                    (OS_STATE)(1u)
N
N#define  OS_STATE_NOT_RDY                    (CPU_BOOLEAN)(0u)
N#define  OS_STATE_RDY                        (CPU_BOOLEAN)(1u)
N
N
N                                                                /* ------------------- TASK STATES ------------------ */
N#define  OS_TASK_STATE_BIT_DLY               (OS_STATE)(0x01u)  /*   /-------- SUSPENDED bit                          */
N                                                                /*   |                                                */
N#define  OS_TASK_STATE_BIT_PEND              (OS_STATE)(0x02u)  /*   | /-----  PEND      bit                          */
N                                                                /*   | |                                              */
N#define  OS_TASK_STATE_BIT_SUSPENDED         (OS_STATE)(0x04u)  /*   | | /---  Delayed/Timeout bit                    */
N                                                                /*   | | |                                            */
N                                                                /*   V V V                                            */
N
N#define  OS_TASK_STATE_RDY                    (OS_STATE)(  0u)  /*   0 0 0     Ready                                  */
N#define  OS_TASK_STATE_DLY                    (OS_STATE)(  1u)  /*   0 0 1     Delayed or Timeout                     */
N#define  OS_TASK_STATE_PEND                   (OS_STATE)(  2u)  /*   0 1 0     Pend                                   */
N#define  OS_TASK_STATE_PEND_TIMEOUT           (OS_STATE)(  3u)  /*   0 1 1     Pend + Timeout                         */
N#define  OS_TASK_STATE_SUSPENDED              (OS_STATE)(  4u)  /*   1 0 0     Suspended                              */
N#define  OS_TASK_STATE_DLY_SUSPENDED          (OS_STATE)(  5u)  /*   1 0 1     Suspended + Delayed or Timeout         */
N#define  OS_TASK_STATE_PEND_SUSPENDED         (OS_STATE)(  6u)  /*   1 1 0     Suspended + Pend                       */
N#define  OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED (OS_STATE)(  7u)  /*   1 1 1     Suspended + Pend + Timeout             */
N#define  OS_TASK_STATE_DEL                    (OS_STATE)(255u)
N
N                                                                /* ----------------- PENDING ON ... ----------------- */
N#define  OS_TASK_PEND_ON_NOTHING              (OS_STATE)(  0u)  /* Pending on nothing                                 */
N#define  OS_TASK_PEND_ON_FLAG                 (OS_STATE)(  1u)  /* Pending on event flag group                        */
N#define  OS_TASK_PEND_ON_TASK_Q               (OS_STATE)(  2u)  /* Pending on message to be sent to task              */
N#define  OS_TASK_PEND_ON_MULTI                (OS_STATE)(  3u)  /* Pending on multiple semaphores and/or queues       */
N#define  OS_TASK_PEND_ON_MUTEX                (OS_STATE)(  4u)  /* Pending on mutual exclusion semaphore              */
N#define  OS_TASK_PEND_ON_Q                    (OS_STATE)(  5u)  /* Pending on queue                                   */
N#define  OS_TASK_PEND_ON_SEM                  (OS_STATE)(  6u)  /* Pending on semaphore                               */
N#define  OS_TASK_PEND_ON_TASK_SEM             (OS_STATE)(  7u)  /* Pending on signal  to be sent to task              */
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                    TASK PEND STATUS
N*                                      (Status codes for OS_TCBs field .PendStatus)
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#define  OS_STATUS_PEND_OK                   (OS_STATUS)(  0u)  /* Pending status OK, !pending, or pending complete   */
N#define  OS_STATUS_PEND_ABORT                (OS_STATUS)(  1u)  /* Pending aborted                                    */
N#define  OS_STATUS_PEND_DEL                  (OS_STATUS)(  2u)  /* Pending object deleted                             */
N#define  OS_STATUS_PEND_TIMEOUT              (OS_STATUS)(  3u)  /* Pending timed out                                  */
N
N/*
N========================================================================================================================
N*                                                   OS OBJECT TYPES
N*
N* Note(s) : (1) OS_OBJ_TYPE_&&& #define values specifically chosen as ASCII representations of the kernel
N*               object types.  Memory displays of kernel objects will display the kernel object TYPEs with
N*               their chosen ASCII names.
N========================================================================================================================
N*/
N
N#define  OS_OBJ_TYPE_NONE                    (OS_OBJ_TYPE)CPU_TYPE_CREATE('N', 'O', 'N', 'E')
N#define  OS_OBJ_TYPE_FLAG                    (OS_OBJ_TYPE)CPU_TYPE_CREATE('F', 'L', 'A', 'G')
N#define  OS_OBJ_TYPE_MEM                     (OS_OBJ_TYPE)CPU_TYPE_CREATE('M', 'E', 'M', ' ')
N#define  OS_OBJ_TYPE_MUTEX                   (OS_OBJ_TYPE)CPU_TYPE_CREATE('M', 'U', 'T', 'X')
N#define  OS_OBJ_TYPE_Q                       (OS_OBJ_TYPE)CPU_TYPE_CREATE('Q', 'U', 'E', 'U')
N#define  OS_OBJ_TYPE_SEM                     (OS_OBJ_TYPE)CPU_TYPE_CREATE('S', 'E', 'M', 'A')
N#define  OS_OBJ_TYPE_TASK_MSG                (OS_OBJ_TYPE)CPU_TYPE_CREATE('T', 'M', 'S', 'G')
N#define  OS_OBJ_TYPE_TASK_RESUME             (OS_OBJ_TYPE)CPU_TYPE_CREATE('T', 'R', 'E', 'S')
N#define  OS_OBJ_TYPE_TASK_SIGNAL             (OS_OBJ_TYPE)CPU_TYPE_CREATE('T', 'S', 'I', 'G')
N#define  OS_OBJ_TYPE_TASK_SUSPEND            (OS_OBJ_TYPE)CPU_TYPE_CREATE('T', 'S', 'U', 'S')
N#define  OS_OBJ_TYPE_TICK                    (OS_OBJ_TYPE)CPU_TYPE_CREATE('T', 'I', 'C', 'K')
N#define  OS_OBJ_TYPE_TMR                     (OS_OBJ_TYPE)CPU_TYPE_CREATE('T', 'M', 'R', ' ')
N
N/*
N========================================================================================================================
N*                                           Possible values for 'opt' argument
N========================================================================================================================
N*/
N
N#define  OS_OPT_NONE                         (OS_OPT)(0x0000u)
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                    DELETE OPTIONS
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#define  OS_OPT_DEL_NO_PEND                  (OS_OPT)(0x0000u)
N#define  OS_OPT_DEL_ALWAYS                   (OS_OPT)(0x0001u)
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                     PEND OPTIONS
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#define  OS_OPT_PEND_FLAG_MASK               (OS_OPT)(0x000Fu)
N#define  OS_OPT_PEND_FLAG_CLR_ALL            (OS_OPT)(0x0001u)  /* Wait for ALL    the bits specified to be CLR       */
N#define  OS_OPT_PEND_FLAG_CLR_AND            (OS_OPT)(0x0001u)
N
N#define  OS_OPT_PEND_FLAG_CLR_ANY            (OS_OPT)(0x0002u)  /* Wait for ANY of the bits specified to be CLR       */
N#define  OS_OPT_PEND_FLAG_CLR_OR             (OS_OPT)(0x0002u)
N
N#define  OS_OPT_PEND_FLAG_SET_ALL            (OS_OPT)(0x0004u)  /* Wait for ALL    the bits specified to be SET       */
N#define  OS_OPT_PEND_FLAG_SET_AND            (OS_OPT)(0x0004u)
N
N#define  OS_OPT_PEND_FLAG_SET_ANY            (OS_OPT)(0x0008u)  /* Wait for ANY of the bits specified to be SET       */
N#define  OS_OPT_PEND_FLAG_SET_OR             (OS_OPT)(0x0008u)
N
N#define  OS_OPT_PEND_FLAG_CONSUME            (OS_OPT)(0x0100u)  /* Consume the flags if condition(s) satisfied        */
N
N
N#define  OS_OPT_PEND_BLOCKING                (OS_OPT)(0x0000u)
N#define  OS_OPT_PEND_NON_BLOCKING            (OS_OPT)(0x8000u)
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                  PEND ABORT OPTIONS
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#define  OS_OPT_PEND_ABORT_1                 (OS_OPT)(0x0000u)  /* Pend abort a single waiting task                   */
N#define  OS_OPT_PEND_ABORT_ALL               (OS_OPT)(0x0100u)  /* Pend abort ALL tasks waiting                       */
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                     POST OPTIONS
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N
N#define  OS_OPT_POST_NONE                    (OS_OPT)(0x0000u)
N
N#define  OS_OPT_POST_FLAG_SET                (OS_OPT)(0x0000u)
N#define  OS_OPT_POST_FLAG_CLR                (OS_OPT)(0x0001u)
N
N#define  OS_OPT_POST_FIFO                    (OS_OPT)(0x0000u)  /* Default is to post FIFO                            */
N#define  OS_OPT_POST_LIFO                    (OS_OPT)(0x0010u)  /* Post to highest priority task waiting              */
N#define  OS_OPT_POST_1                       (OS_OPT)(0x0000u)  /* Post message to highest priority task waiting      */
N#define  OS_OPT_POST_ALL                     (OS_OPT)(0x0200u)  /* Broadcast message to ALL tasks waiting             */
N
N#define  OS_OPT_POST_NO_SCHED                (OS_OPT)(0x8000u)  /* Do not call the scheduler if this is selected      */
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                     TASK OPTIONS
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#define  OS_OPT_TASK_NONE                    (OS_OPT)(0x0000u)  /* No option selected                                 */
N#define  OS_OPT_TASK_STK_CHK                 (OS_OPT)(0x0001u)  /* Enable stack checking for the task                 */
N#define  OS_OPT_TASK_STK_CLR                 (OS_OPT)(0x0002u)  /* Clear the stack when the task is create            */
N#define  OS_OPT_TASK_SAVE_FP                 (OS_OPT)(0x0004u)  /* Save the contents of any floating-point registers  */
N#define  OS_OPT_TASK_NO_TLS                  (OS_OPT)(0x0008u)  /* Specifies the task DOES NOT require TLS support    */
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                     TIME OPTIONS
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#define  OS_OPT_TIME_DLY                             DEF_BIT_NONE
N#define  OS_OPT_TIME_TIMEOUT                ((OS_OPT)DEF_BIT_01)
N#define  OS_OPT_TIME_MATCH                  ((OS_OPT)DEF_BIT_02)
N#define  OS_OPT_TIME_PERIODIC               ((OS_OPT)DEF_BIT_03)
N
N#define  OS_OPT_TIME_HMSM_STRICT            ((OS_OPT)DEF_BIT_NONE)
N#define  OS_OPT_TIME_HMSM_NON_STRICT        ((OS_OPT)DEF_BIT_04)
N
N#define  OS_OPT_TIME_MASK                   ((OS_OPT)(OS_OPT_TIME_DLY      | \
N                                                      OS_OPT_TIME_TIMEOUT  | \
N                                                      OS_OPT_TIME_PERIODIC | \
N                                                      OS_OPT_TIME_MATCH))
X#define  OS_OPT_TIME_MASK                   ((OS_OPT)(OS_OPT_TIME_DLY      |                                                       OS_OPT_TIME_TIMEOUT  |                                                       OS_OPT_TIME_PERIODIC |                                                       OS_OPT_TIME_MATCH))
N
N#define  OS_OPT_TIME_OPTS_MASK                       (OS_OPT_TIME_DLY            | \
N                                                      OS_OPT_TIME_TIMEOUT        | \
N                                                      OS_OPT_TIME_PERIODIC       | \
N                                                      OS_OPT_TIME_MATCH          | \
N                                                      OS_OPT_TIME_HMSM_NON_STRICT)
X#define  OS_OPT_TIME_OPTS_MASK                       (OS_OPT_TIME_DLY            |                                                       OS_OPT_TIME_TIMEOUT        |                                                       OS_OPT_TIME_PERIODIC       |                                                       OS_OPT_TIME_MATCH          |                                                       OS_OPT_TIME_HMSM_NON_STRICT)
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                    TIMER OPTIONS
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#define  OS_OPT_TMR_NONE                          (OS_OPT)(0u)  /* No option selected                                 */
N
N#define  OS_OPT_TMR_ONE_SHOT                      (OS_OPT)(1u)  /* Timer will not auto restart when it expires        */
N#define  OS_OPT_TMR_PERIODIC                      (OS_OPT)(2u)  /* Timer will     auto restart when it expires        */
N
N#define  OS_OPT_TMR_CALLBACK                      (OS_OPT)(3u)  /* OSTmrStop() option to call 'callback' w/ timer arg */
N#define  OS_OPT_TMR_CALLBACK_ARG                  (OS_OPT)(4u)  /* OSTmrStop() option to call 'callback' w/ new   arg */
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                     TIMER STATES
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#define  OS_TMR_STATE_UNUSED                    (OS_STATE)(0u)
N#define  OS_TMR_STATE_STOPPED                   (OS_STATE)(1u)
N#define  OS_TMR_STATE_RUNNING                   (OS_STATE)(2u)
N#define  OS_TMR_STATE_COMPLETED                 (OS_STATE)(3u)
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                       PRIORITY
N------------------------------------------------------------------------------------------------------------------------
N*/
N                                                                    /* Dflt prio to init task TCB                     */
N#define  OS_PRIO_INIT                       (OS_PRIO)(OS_CFG_PRIO_MAX)
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                 TIMER TICK THRESHOLDS
N------------------------------------------------------------------------------------------------------------------------
N*/
N                                                                    /* Threshold to init previous tick time           */
N#define  OS_TICK_TH_INIT                    (OS_TICK)(DEF_BIT       ((sizeof(OS_TICK) * DEF_OCTET_NBR_BITS) - 1u))
N
N                                                                    /* Threshold to check if tick time already ready  */
N#define  OS_TICK_TH_RDY                     (OS_TICK)(DEF_BIT_FIELD(((sizeof(OS_TICK) * DEF_OCTET_NBR_BITS) / 2u), \
N                                                                    ((sizeof(OS_TICK) * DEF_OCTET_NBR_BITS) / 2u)))
X#define  OS_TICK_TH_RDY                     (OS_TICK)(DEF_BIT_FIELD(((sizeof(OS_TICK) * DEF_OCTET_NBR_BITS) / 2u),                                                                     ((sizeof(OS_TICK) * DEF_OCTET_NBR_BITS) / 2u)))
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                                                E N U M E R A T I O N S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                      ERROR CODES
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Ntypedef  enum  os_err {
N    OS_ERR_NONE                      =     0u,
N
N    OS_ERR_A                         = 10000u,
N    OS_ERR_ACCEPT_ISR                = 10001u,
N
N    OS_ERR_B                         = 11000u,
N
N    OS_ERR_C                         = 12000u,
N    OS_ERR_CREATE_ISR                = 12001u,
N
N    OS_ERR_D                         = 13000u,
N    OS_ERR_DEL_ISR                   = 13001u,
N
N    OS_ERR_E                         = 14000u,
N
N    OS_ERR_F                         = 15000u,
N    OS_ERR_FATAL_RETURN              = 15001u,
N
N    OS_ERR_FLAG_GRP_DEPLETED         = 15101u,
N    OS_ERR_FLAG_NOT_RDY              = 15102u,
N    OS_ERR_FLAG_PEND_OPT             = 15103u,
N    OS_ERR_FLUSH_ISR                 = 15104u,
N
N    OS_ERR_G                         = 16000u,
N
N    OS_ERR_H                         = 17000u,
N
N    OS_ERR_I                         = 18000u,
N    OS_ERR_ILLEGAL_CREATE_RUN_TIME   = 18001u,
N    OS_ERR_INT_Q                     = 18002u,
N    OS_ERR_INT_Q_FULL                = 18003u,
N    OS_ERR_INT_Q_SIZE                = 18004u,
N    OS_ERR_INT_Q_STK_INVALID         = 18005u,
N    OS_ERR_INT_Q_STK_SIZE_INVALID    = 18006u,
N
N    OS_ERR_J                         = 19000u,
N
N    OS_ERR_K                         = 20000u,
N
N    OS_ERR_L                         = 21000u,
N    OS_ERR_LOCK_NESTING_OVF          = 21001u,
N
N    OS_ERR_M                         = 22000u,
N
N    OS_ERR_MEM_CREATE_ISR            = 22201u,
N    OS_ERR_MEM_FULL                  = 22202u,
N    OS_ERR_MEM_INVALID_P_ADDR        = 22203u,
N    OS_ERR_MEM_INVALID_BLKS          = 22204u,
N    OS_ERR_MEM_INVALID_PART          = 22205u,
N    OS_ERR_MEM_INVALID_P_BLK         = 22206u,
N    OS_ERR_MEM_INVALID_P_MEM         = 22207u,
N    OS_ERR_MEM_INVALID_P_DATA        = 22208u,
N    OS_ERR_MEM_INVALID_SIZE          = 22209u,
N    OS_ERR_MEM_NO_FREE_BLKS          = 22210u,
N
N    OS_ERR_MSG_POOL_EMPTY            = 22301u,
N    OS_ERR_MSG_POOL_NULL_PTR         = 22302u,
N
N    OS_ERR_MUTEX_NOT_OWNER           = 22401u,
N    OS_ERR_MUTEX_OWNER               = 22402u,
N    OS_ERR_MUTEX_NESTING             = 22403u,
N
N    OS_ERR_N                         = 23000u,
N    OS_ERR_NAME                      = 23001u,
N    OS_ERR_NO_MORE_ID_AVAIL          = 23002u,
N
N    OS_ERR_O                         = 24000u,
N    OS_ERR_OBJ_CREATED               = 24001u,
N    OS_ERR_OBJ_DEL                   = 24002u,
N    OS_ERR_OBJ_PTR_NULL              = 24003u,
N    OS_ERR_OBJ_TYPE                  = 24004u,
N
N    OS_ERR_OPT_INVALID               = 24101u,
N
N    OS_ERR_OS_NOT_RUNNING            = 24201u,
N    OS_ERR_OS_RUNNING                = 24202u,
N
N    OS_ERR_P                         = 25000u,
N    OS_ERR_PEND_ABORT                = 25001u,
N    OS_ERR_PEND_ABORT_ISR            = 25002u,
N    OS_ERR_PEND_ABORT_NONE           = 25003u,
N    OS_ERR_PEND_ABORT_SELF           = 25004u,
N    OS_ERR_PEND_DEL                  = 25005u,
N    OS_ERR_PEND_ISR                  = 25006u,
N    OS_ERR_PEND_LOCKED               = 25007u,
N    OS_ERR_PEND_WOULD_BLOCK          = 25008u,
N
N    OS_ERR_POST_NULL_PTR             = 25101u,
N    OS_ERR_POST_ISR                  = 25102u,
N
N    OS_ERR_PRIO_EXIST                = 25201u,
N    OS_ERR_PRIO                      = 25202u,
N    OS_ERR_PRIO_INVALID              = 25203u,
N
N    OS_ERR_PTR_INVALID               = 25301u,
N
N    OS_ERR_Q                         = 26000u,
N    OS_ERR_Q_FULL                    = 26001u,
N    OS_ERR_Q_EMPTY                   = 26002u,
N    OS_ERR_Q_MAX                     = 26003u,
N    OS_ERR_Q_SIZE                    = 26004u,
N
N    OS_ERR_R                         = 27000u,
N    OS_ERR_REG_ID_INVALID            = 27001u,
N    OS_ERR_ROUND_ROBIN_1             = 27002u,
N    OS_ERR_ROUND_ROBIN_DISABLED      = 27003u,
N
N    OS_ERR_S                         = 28000u,
N    OS_ERR_SCHED_INVALID_TIME_SLICE  = 28001u,
N    OS_ERR_SCHED_LOCK_ISR            = 28002u,
N    OS_ERR_SCHED_LOCKED              = 28003u,
N    OS_ERR_SCHED_NOT_LOCKED          = 28004u,
N    OS_ERR_SCHED_UNLOCK_ISR          = 28005u,
N
N    OS_ERR_SEM_OVF                   = 28101u,
N    OS_ERR_SET_ISR                   = 28102u,
N
N    OS_ERR_STAT_RESET_ISR            = 28201u,
N    OS_ERR_STAT_PRIO_INVALID         = 28202u,
N    OS_ERR_STAT_STK_INVALID          = 28203u,
N    OS_ERR_STAT_STK_SIZE_INVALID     = 28204u,
N    OS_ERR_STATE_INVALID             = 28205u,
N    OS_ERR_STATUS_INVALID            = 28206u,
N    OS_ERR_STK_INVALID               = 28207u,
N    OS_ERR_STK_SIZE_INVALID          = 28208u,
N    OS_ERR_STK_LIMIT_INVALID         = 28209u,
N
N    OS_ERR_T                         = 29000u,
N    OS_ERR_TASK_CHANGE_PRIO_ISR      = 29001u,
N    OS_ERR_TASK_CREATE_ISR           = 29002u,
N    OS_ERR_TASK_DEL                  = 29003u,
N    OS_ERR_TASK_DEL_IDLE             = 29004u,
N    OS_ERR_TASK_DEL_INVALID          = 29005u,
N    OS_ERR_TASK_DEL_ISR              = 29006u,
N    OS_ERR_TASK_INVALID              = 29007u,
N    OS_ERR_TASK_NO_MORE_TCB          = 29008u,
N    OS_ERR_TASK_NOT_DLY              = 29009u,
N    OS_ERR_TASK_NOT_EXIST            = 29010u,
N    OS_ERR_TASK_NOT_SUSPENDED        = 29011u,
N    OS_ERR_TASK_OPT                  = 29012u,
N    OS_ERR_TASK_RESUME_ISR           = 29013u,
N    OS_ERR_TASK_RESUME_PRIO          = 29014u,
N    OS_ERR_TASK_RESUME_SELF          = 29015u,
N    OS_ERR_TASK_RUNNING              = 29016u,
N    OS_ERR_TASK_STK_CHK_ISR          = 29017u,
N    OS_ERR_TASK_SUSPENDED            = 29018u,
N    OS_ERR_TASK_SUSPEND_IDLE         = 29019u,
N    OS_ERR_TASK_SUSPEND_INT_HANDLER  = 29020u,
N    OS_ERR_TASK_SUSPEND_ISR          = 29021u,
N    OS_ERR_TASK_SUSPEND_PRIO         = 29022u,
N    OS_ERR_TASK_WAITING              = 29023u,
N
N    OS_ERR_TCB_INVALID               = 29101u,
N
N    OS_ERR_TLS_ID_INVALID            = 29120u,
N    OS_ERR_TLS_ISR                   = 29121u,
N    OS_ERR_TLS_NO_MORE_AVAIL         = 29122u,
N    OS_ERR_TLS_NOT_EN                = 29123u,
N    OS_ERR_TLS_DESTRUCT_ASSIGNED     = 29124u,
N
N    OS_ERR_TICK_PRIO_INVALID         = 29201u,
N    OS_ERR_TICK_STK_INVALID          = 29202u,
N    OS_ERR_TICK_STK_SIZE_INVALID     = 29203u,
N    OS_ERR_TICK_WHEEL_SIZE           = 29204u,
N
N    OS_ERR_TIME_DLY_ISR              = 29301u,
N    OS_ERR_TIME_DLY_RESUME_ISR       = 29302u,
N    OS_ERR_TIME_GET_ISR              = 29303u,
N    OS_ERR_TIME_INVALID_HOURS        = 29304u,
N    OS_ERR_TIME_INVALID_MINUTES      = 29305u,
N    OS_ERR_TIME_INVALID_SECONDS      = 29306u,
N    OS_ERR_TIME_INVALID_MILLISECONDS = 29307u,
N    OS_ERR_TIME_NOT_DLY              = 29308u,
N    OS_ERR_TIME_SET_ISR              = 29309u,
N    OS_ERR_TIME_ZERO_DLY             = 29310u,
N
N    OS_ERR_TIMEOUT                   = 29401u,
N
N    OS_ERR_TMR_INACTIVE              = 29501u,
N    OS_ERR_TMR_INVALID_DEST          = 29502u,
N    OS_ERR_TMR_INVALID_DLY           = 29503u,
N    OS_ERR_TMR_INVALID_PERIOD        = 29504u,
N    OS_ERR_TMR_INVALID_STATE         = 29505u,
N    OS_ERR_TMR_INVALID               = 29506u,
N    OS_ERR_TMR_ISR                   = 29507u,
N    OS_ERR_TMR_NO_CALLBACK           = 29508u,
N    OS_ERR_TMR_NON_AVAIL             = 29509u,
N    OS_ERR_TMR_PRIO_INVALID          = 29510u,
N    OS_ERR_TMR_STK_INVALID           = 29511u,
N    OS_ERR_TMR_STK_SIZE_INVALID      = 29512u,
N    OS_ERR_TMR_STOPPED               = 29513u,
N
N    OS_ERR_U                         = 30000u,
N
N    OS_ERR_V                         = 31000u,
N
N    OS_ERR_W                         = 32000u,
N
N    OS_ERR_X                         = 33000u,
N
N    OS_ERR_Y                         = 34000u,
N    OS_ERR_YIELD_ISR                 = 34001u,
N
N    OS_ERR_Z                         = 35000u
N} OS_ERR;
N
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                                                  D A T A   T Y P E S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
Ntypedef  struct  os_flag_grp         OS_FLAG_GRP;
N
Ntypedef  struct  os_mem              OS_MEM;
N
Ntypedef  struct  os_msg              OS_MSG;
Ntypedef  struct  os_msg_pool         OS_MSG_POOL;
Ntypedef  struct  os_msg_q            OS_MSG_Q;
N
Ntypedef  struct  os_mutex            OS_MUTEX;
N
Ntypedef  struct  os_int_q            OS_INT_Q;
N
Ntypedef  struct  os_q                OS_Q;
N
Ntypedef  struct  os_sem              OS_SEM;
N
Ntypedef  void                      (*OS_TASK_PTR)(void *p_arg);
N
Ntypedef  struct  os_tcb              OS_TCB;
N
N#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
X#if 0L && (OS_CFG_TLS_TBL_SIZE > 0u)
Stypedef  void                       *OS_TLS;
S
Stypedef  CPU_DATA                    OS_TLS_ID;
S
Stypedef  void                      (*OS_TLS_DESTRUCT_PTR)(OS_TCB    *p_tcb,
S                                                          OS_TLS_ID  id,
S                                                          OS_TLS     value);
N#endif
N
Ntypedef  struct  os_rdy_list         OS_RDY_LIST;
N
Ntypedef  struct  os_tick_spoke       OS_TICK_SPOKE;
N
Ntypedef  void                      (*OS_TMR_CALLBACK_PTR)(void *p_tmr, void *p_arg);
Ntypedef  struct  os_tmr              OS_TMR;
Ntypedef  struct  os_tmr_spoke        OS_TMR_SPOKE;
N
N
Ntypedef  struct  os_pend_data        OS_PEND_DATA;
Ntypedef  struct  os_pend_list        OS_PEND_LIST;
Ntypedef  struct  os_pend_obj         OS_PEND_OBJ;
N
N#if OS_CFG_APP_HOOKS_EN > 0u
X#if 1u > 0u
Ntypedef  void                      (*OS_APP_HOOK_VOID)(void);
Ntypedef  void                      (*OS_APP_HOOK_TCB)(OS_TCB *p_tcb);
N#endif
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                                          D A T A   S T R U C T U R E S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                    ISR POST DATA
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
X#if 0u > 0u
Sstruct  os_int_q {
S    OS_OBJ_TYPE          Type;                              /* Type of object placed in the circular list             */
S    OS_INT_Q            *NextPtr;                           /* Pointer to next OS_INT_Q in  circular list             */
S    void                *ObjPtr;                            /* Pointer to object placed in the queue                  */
S    void                *MsgPtr;                            /* Pointer to message if posting to a message queue       */
S    OS_MSG_SIZE          MsgSize;                           /* Message Size       if posting to a message queue       */
S    OS_FLAGS             Flags;                             /* Value of flags if posting to an event flag group       */
S    OS_OPT               Opt;                               /* Post Options                                           */
S    CPU_TS               TS;                                /* Timestamp                                              */
S};
N#endif
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                      READY LIST
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_rdy_list {
N    OS_TCB              *HeadPtr;                           /* Pointer to task that will run at selected priority     */
N    OS_TCB              *TailPtr;                           /* Pointer to last task          at selected priority     */
N    OS_OBJ_QTY           NbrEntries;                        /* Number of entries             at selected priority     */
N};
N
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                PEND DATA and PEND LIST
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_pend_data {
N    OS_PEND_DATA        *PrevPtr;
N    OS_PEND_DATA        *NextPtr;
N    OS_TCB              *TCBPtr;
N    OS_PEND_OBJ         *PendObjPtr;
N    OS_PEND_OBJ         *RdyObjPtr;
N    void                *RdyMsgPtr;
N    OS_MSG_SIZE          RdyMsgSize;
N    CPU_TS               RdyTS;
N};
N
N
Nstruct  os_pend_list {
N    OS_PEND_DATA        *HeadPtr;
N    OS_PEND_DATA        *TailPtr;
N    OS_OBJ_QTY           NbrEntries;
N};
N
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                       PEND OBJ
N*
N* Note(s) : (1) The 'os_pend_obj' structure data type is a template/subset for specific kernel objects' data types:
N*               'os_flag_grp', 'os_mutex', 'os_q', and 'os_sem'.  Each specific kernel object data type MUST define
N*               ALL generic OS pend object parameters, synchronized in both the sequential order & data type of each
N*               parameter.
N*
N*               Thus, ANY modification to the sequential order or data types of OS pend object parameters MUST be
N*               appropriately synchronized between the generic OS pend object data type & ALL specific kernel objects'
N*               data types.
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_pend_obj {
N    OS_OBJ_TYPE          Type;
N    CPU_CHAR            *NamePtr;
N    OS_PEND_LIST         PendList;                          /* List of tasks pending on object                        */
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
N    void                *DbgPrevPtr;
N    void                *DbgNextPtr;
N    CPU_CHAR            *DbgNamePtr;
N#endif
N};
N
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                     EVENT FLAGS
N*
N* Note(s) : See  PEND OBJ  Note #1'.
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N
Nstruct  os_flag_grp {                                       /* Event Flag Group                                       */
N                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
N    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_FLAG                      */
N    CPU_CHAR            *NamePtr;                           /* Pointer to Event Flag Name (NUL terminated ASCII)      */
N    OS_PEND_LIST         PendList;                          /* List of tasks waiting on event flag group              */
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
N    OS_FLAG_GRP         *DbgPrevPtr;
N    OS_FLAG_GRP         *DbgNextPtr;
N    CPU_CHAR            *DbgNamePtr;
N#endif
N                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
N    OS_FLAGS             Flags;                             /* 8, 16 or 32 bit flags                                  */
N    CPU_TS               TS;                                /* Timestamp of when last post occurred                   */
N};
N
N/*$PAGE*/
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                   MEMORY PARTITIONS
N------------------------------------------------------------------------------------------------------------------------
N*/
N
N
Nstruct os_mem {                                             /* MEMORY CONTROL BLOCK                                   */
N    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_MEM                       */
N    void                *AddrPtr;                           /* Pointer to beginning of memory partition               */
N    CPU_CHAR            *NamePtr;
N    void                *FreeListPtr;                       /* Pointer to list of free memory blocks                  */
N    OS_MEM_SIZE          BlkSize;                           /* Size (in bytes) of each block of memory                */
N    OS_MEM_QTY           NbrMax;                            /* Total number of blocks in this partition               */
N    OS_MEM_QTY           NbrFree;                           /* Number of memory blocks remaining in this partition    */
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
N    OS_MEM              *DbgPrevPtr;
N    OS_MEM              *DbgNextPtr;
N#endif
N};
N
N/*$PAGE*/
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                       MESSAGES
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_msg {                                            /* MESSAGE CONTROL BLOCK                                  */
N    OS_MSG              *NextPtr;                           /* Pointer to next message                                */
N    void                *MsgPtr;                            /* Actual message                                         */
N    OS_MSG_SIZE          MsgSize;                           /* Size of the message (in # bytes)                       */
N    CPU_TS               MsgTS;                             /* Time stamp of when message was sent                    */
N};
N
N
N
N
Nstruct  os_msg_pool {                                       /* OS_MSG POOL                                            */
N    OS_MSG              *NextPtr;                           /* Pointer to next message                                */
N    OS_MSG_QTY           NbrFree;                           /* Number of messages available from this pool            */
N    OS_MSG_QTY           NbrUsed;                           /* Current number of messages used                        */
N    OS_MSG_QTY           NbrUsedMax;                        /* Peak number of messages used                           */
N};
N
N
N
Nstruct  os_msg_q {                                          /* OS_MSG_Q                                               */
N    OS_MSG              *InPtr;                             /* Pointer to next OS_MSG to be inserted  in   the queue  */
N    OS_MSG              *OutPtr;                            /* Pointer to next OS_MSG to be extracted from the queue  */
N    OS_MSG_QTY           NbrEntriesSize;                    /* Maximum allowable number of entries in the queue       */
N    OS_MSG_QTY           NbrEntries;                        /* Current number of entries in the queue                 */
N    OS_MSG_QTY           NbrEntriesMax;                     /* Peak number of entries in the queue                    */
N};
N
N/*$PAGE*/
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                              MUTUAL EXCLUSION SEMAPHORES
N*
N* Note(s) : See  PEND OBJ  Note #1'.
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_mutex {                                          /* Mutual Exclusion Semaphore                             */
N                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
N    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_MUTEX                     */
N    CPU_CHAR            *NamePtr;                           /* Pointer to Mutex Name (NUL terminated ASCII)           */
N    OS_PEND_LIST         PendList;                          /* List of tasks waiting on mutex                         */
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
N    OS_MUTEX            *DbgPrevPtr;
N    OS_MUTEX            *DbgNextPtr;
N    CPU_CHAR            *DbgNamePtr;
N#endif
N                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
N    OS_TCB              *OwnerTCBPtr;
N    OS_PRIO              OwnerOriginalPrio;
N    OS_NESTING_CTR       OwnerNestingCtr;                   /* Mutex is available when the counter is 0               */
N    CPU_TS               TS;
N};
N
N/*$PAGE*/
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                    MESSAGE QUEUES
N*
N* Note(s) : See  PEND OBJ  Note #1'.
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_q {                                              /* Message Queue                                          */
N                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
N    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_Q                         */
N    CPU_CHAR            *NamePtr;                           /* Pointer to Message Queue Name (NUL terminated ASCII)   */
N    OS_PEND_LIST         PendList;                          /* List of tasks waiting on message queue                 */
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
N    OS_Q                *DbgPrevPtr;
N    OS_Q                *DbgNextPtr;
N    CPU_CHAR            *DbgNamePtr;
N#endif
N                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
N    OS_MSG_Q             MsgQ;                              /* List of messages                                       */
N};
N
N/*$PAGE*/
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                      SEMAPHORES
N*
N* Note(s) : See  PEND OBJ  Note #1'.
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_sem {                                            /* Semaphore                                              */
N                                                            /* ------------------ GENERIC  MEMBERS ------------------ */
N    OS_OBJ_TYPE          Type;                              /* Should be set to OS_OBJ_TYPE_SEM                       */
N    CPU_CHAR            *NamePtr;                           /* Pointer to Semaphore Name (NUL terminated ASCII)       */
N    OS_PEND_LIST         PendList;                          /* List of tasks waiting on semaphore                     */
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
N    OS_SEM              *DbgPrevPtr;
N    OS_SEM              *DbgNextPtr;
N    CPU_CHAR            *DbgNamePtr;
N#endif
N                                                            /* ------------------ SPECIFIC MEMBERS ------------------ */
N    OS_SEM_CTR           Ctr;
N    CPU_TS               TS;
N};
N
N/*$PAGE*/
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                  TASK CONTROL BLOCK
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct os_tcb {
N    CPU_STK             *StkPtr;                            /* Pointer to current top of stack                        */
N
N    void                *ExtPtr;                            /* Pointer to user definable data for TCB extension       */
N
N    CPU_STK             *StkLimitPtr;                       /* Pointer used to set stack 'watermark' limit            */
N
N    OS_TCB              *NextPtr;                           /* Pointer to next     TCB in the TCB list                */
N    OS_TCB              *PrevPtr;                           /* Pointer to previous TCB in the TCB list                */
N
N    OS_TCB              *TickNextPtr;
N    OS_TCB              *TickPrevPtr;
N
N    OS_TICK_SPOKE       *TickSpokePtr;                      /* Pointer to tick spoke if task is in the tick list      */
N
N    CPU_CHAR            *NamePtr;                           /* Pointer to task name                                   */
N
N    CPU_STK             *StkBasePtr;                        /* Pointer to base address of stack                       */
N
N#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
X#if 0L && (OS_CFG_TLS_TBL_SIZE > 0u)
S    OS_TLS               TLS_Tbl[OS_CFG_TLS_TBL_SIZE];
N#endif
N
N    OS_TASK_PTR          TaskEntryAddr;                     /* Pointer to task entry point address                    */
N    void                *TaskEntryArg;                      /* Argument passed to task when it was created            */
N
N    OS_PEND_DATA        *PendDataTblPtr;                    /* Pointer to list containing objects pended on           */
N    OS_STATE             PendOn;                            /* Indicates what task is pending on                      */
N    OS_STATUS            PendStatus;                        /* Pend status                                            */
N
N    OS_STATE             TaskState;                         /* See OS_TASK_STATE_xxx                                  */
N    OS_PRIO              Prio;                              /* Task priority (0 == highest)                           */
N    CPU_STK_SIZE         StkSize;                           /* Size of task stack (in number of stack elements)       */
N    OS_OPT               Opt;                               /* Task options as passed by OSTaskCreate()               */
N
N    OS_OBJ_QTY           PendDataTblEntries;                /* Size of array of objects to pend on                    */
N
N    CPU_TS               TS;                                /* Timestamp                                              */
N
N    OS_SEM_CTR           SemCtr;                            /* Task specific semaphore counter                        */
N
N                                                            /* DELAY / TIMEOUT                                        */
N    OS_TICK              TickCtrPrev;                       /* Previous time when task was            ready           */
N    OS_TICK              TickCtrMatch;                      /* Absolute time when task is going to be ready           */
N    OS_TICK              TickRemain;                        /* Number of ticks remaining for a match (updated at ...  */
N                                                            /* ... run-time by OS_StatTask()                          */
N    OS_TICK              TimeQuanta;
N    OS_TICK              TimeQuantaCtr;
N
N#if OS_MSG_EN > 0u
X#if (((1u > 0u) || (1u > 0u)) ? 1u : 0u) > 0u
N    void                *MsgPtr;                            /* Message received                                       */
N    OS_MSG_SIZE          MsgSize;
N#endif
N
N#if OS_CFG_TASK_Q_EN > 0u
X#if 1u > 0u
N    OS_MSG_Q             MsgQ;                              /* Message queue associated with task                     */
N#if OS_CFG_TASK_PROFILE_EN > 0u
X#if 1u > 0u
N    CPU_TS               MsgQPendTime;                      /* Time it took for signal to be received                 */
N    CPU_TS               MsgQPendTimeMax;                   /* Max amount of time it took for signal to be received   */
N#endif
N#endif
N
N#if OS_CFG_TASK_REG_TBL_SIZE > 0u
X#if 1u > 0u
N    OS_REG               RegTbl[OS_CFG_TASK_REG_TBL_SIZE];  /* Task specific registers                                */
X    OS_REG               RegTbl[1u];
N#endif
N
N#if OS_CFG_FLAG_EN > 0u
X#if 1u > 0u
N    OS_FLAGS             FlagsPend;                         /* Event flag(s) to wait on                               */
N    OS_FLAGS             FlagsRdy;                          /* Event flags that made task ready to run                */
N    OS_OPT               FlagsOpt;                          /* Options (See OS_OPT_FLAG_xxx)                          */
N#endif
N
N#if OS_CFG_TASK_SUSPEND_EN > 0u
X#if 1u > 0u
N    OS_NESTING_CTR       SuspendCtr;                        /* Nesting counter for OSTaskSuspend()                    */
N#endif
N
N#if OS_CFG_TASK_PROFILE_EN > 0u
X#if 1u > 0u
N    OS_CPU_USAGE         CPUUsage;                          /* CPU Usage of task (0.00-100.00%)                       */
N    OS_CPU_USAGE         CPUUsageMax;                       /* CPU Usage of task (0.00-100.00%) - Peak                */
N    OS_CTX_SW_CTR        CtxSwCtr;                          /* Number of time the task was switched in                */
N    CPU_TS               CyclesDelta;                       /* value of OS_TS_GET() - .CyclesStart                    */
N    CPU_TS               CyclesStart;                       /* Snapshot of cycle counter at start of task resumption  */
N    OS_CYCLES            CyclesTotal;                       /* Total number of # of cycles the task has been running  */
N    OS_CYCLES            CyclesTotalPrev;                   /* Snapshot of previous # of cycles                       */
N
N    CPU_TS               SemPendTime;                       /* Time it took for signal to be received                 */
N    CPU_TS               SemPendTimeMax;                    /* Max amount of time it took for signal to be received   */
N#endif
N
N#if OS_CFG_STAT_TASK_STK_CHK_EN > 0u
X#if 1u > 0u
N    CPU_STK_SIZE         StkUsed;                           /* Number of stack elements used from the stack           */
N    CPU_STK_SIZE         StkFree;                           /* Number of stack elements free on   the stack           */
N#endif
N
N#ifdef CPU_CFG_INT_DIS_MEAS_EN
S    CPU_TS               IntDisTimeMax;                     /* Maximum interrupt disable time                         */
N#endif
N#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u
X#if 0u > 0u
S    CPU_TS               SchedLockTimeMax;                  /* Maximum scheduler lock time                            */
N#endif
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
N    OS_TCB              *DbgPrevPtr;
N    OS_TCB              *DbgNextPtr;
N    CPU_CHAR            *DbgNamePtr;
N#endif
N};
N
N/*$PAGE*/
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                    TICK DATA TYPE
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_tick_spoke {
N    OS_TCB              *FirstPtr;                          /* Pointer to list of tasks in tick spoke                 */
N    OS_OBJ_QTY           NbrEntries;                        /* Current number of entries in the tick spoke            */
N    OS_OBJ_QTY           NbrEntriesMax;                     /* Peak number of entries in the tick spoke               */
N};
N
N
N/*
N------------------------------------------------------------------------------------------------------------------------
N*                                                   TIMER DATA TYPES
N------------------------------------------------------------------------------------------------------------------------
N*/
N
Nstruct  os_tmr {
N    OS_OBJ_TYPE          Type;
N    CPU_CHAR            *NamePtr;                           /* Name to give the timer                                 */
N    OS_TMR_CALLBACK_PTR  CallbackPtr;                       /* Function to call when timer expires                    */
N    void                *CallbackPtrArg;                    /* Argument to pass to function when timer expires        */
N    OS_TMR              *NextPtr;                           /* Double link list pointers                              */
N    OS_TMR              *PrevPtr;
N    OS_TICK              Match;                             /* Timer expires when OSTmrTickCtr matches this value     */
N    OS_TICK              Remain;                            /* Amount of time remaining before timer expires          */
N    OS_TICK              Dly;                               /* Delay before start of repeat                           */
N    OS_TICK              Period;                            /* Period to repeat timer                                 */
N    OS_OPT               Opt;                               /* Options (see OS_OPT_TMR_xxx)                           */
N    OS_STATE             State;
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
N    OS_TMR              *DbgPrevPtr;
N    OS_TMR              *DbgNextPtr;
N#endif
N};
N
N
N
Nstruct  os_tmr_spoke {
N    OS_TMR              *FirstPtr;                          /* Pointer to first timer in linked list                  */
N    OS_OBJ_QTY           NbrEntries;
N    OS_OBJ_QTY           NbrEntriesMax;
N};
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                                           G L O B A L   V A R I A B L E S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
N#if OS_CFG_APP_HOOKS_EN > 0u
X#if 1u > 0u
NOS_EXT           OS_APP_HOOK_TCB            OS_AppTaskCreateHookPtr;    /* Application hooks                          */
Xextern           OS_APP_HOOK_TCB            OS_AppTaskCreateHookPtr;
NOS_EXT           OS_APP_HOOK_TCB            OS_AppTaskDelHookPtr;
Xextern           OS_APP_HOOK_TCB            OS_AppTaskDelHookPtr;
NOS_EXT           OS_APP_HOOK_TCB            OS_AppTaskReturnHookPtr;
Xextern           OS_APP_HOOK_TCB            OS_AppTaskReturnHookPtr;
N
NOS_EXT           OS_APP_HOOK_VOID           OS_AppIdleTaskHookPtr;
Xextern           OS_APP_HOOK_VOID           OS_AppIdleTaskHookPtr;
NOS_EXT           OS_APP_HOOK_VOID           OS_AppStatTaskHookPtr;
Xextern           OS_APP_HOOK_VOID           OS_AppStatTaskHookPtr;
NOS_EXT           OS_APP_HOOK_VOID           OS_AppTaskSwHookPtr;
Xextern           OS_APP_HOOK_VOID           OS_AppTaskSwHookPtr;
NOS_EXT           OS_APP_HOOK_VOID           OS_AppTimeTickHookPtr;
Xextern           OS_APP_HOOK_VOID           OS_AppTimeTickHookPtr;
N#endif
N
N                                                                        /* IDLE TASK -------------------------------- */
NOS_EXT            OS_IDLE_CTR               OSIdleTaskCtr;
Xextern            OS_IDLE_CTR               OSIdleTaskCtr;
NOS_EXT            OS_TCB                    OSIdleTaskTCB;
Xextern            OS_TCB                    OSIdleTaskTCB;
N
N                                                                        /* MISCELLANEOUS ---------------------------- */
NOS_EXT            OS_NESTING_CTR            OSIntNestingCtr;            /* Interrupt nesting level                    */
Xextern            OS_NESTING_CTR            OSIntNestingCtr;
N#ifdef CPU_CFG_INT_DIS_MEAS_EN
SOS_EXT            CPU_TS                    OSIntDisTimeMax;            /* Overall interrupt disable time             */
N#endif
N
NOS_EXT            OS_STATE                  OSRunning;                  /* Flag indicating that kernel is running     */
Xextern            OS_STATE                  OSRunning;
N
N
N                                                                        /* ISR HANDLER TASK ------------------------- */
N#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
X#if 0u > 0u
SOS_EXT            OS_INT_Q                 *OSIntQInPtr;
SOS_EXT            OS_INT_Q                 *OSIntQOutPtr;
SOS_EXT            OS_OBJ_QTY                OSIntQNbrEntries;
SOS_EXT            OS_OBJ_QTY                OSIntQNbrEntriesMax;
SOS_EXT            OS_OBJ_QTY                OSIntQOvfCtr;
SOS_EXT            OS_TCB                    OSIntQTaskTCB;
SOS_EXT            CPU_TS                    OSIntQTaskTimeMax;
N#endif
N
N                                                                        /* FLAGS ------------------------------------ */
N#if OS_CFG_FLAG_EN > 0u
X#if 1u > 0u
N#if OS_CFG_DBG_EN  > 0u
X#if 1u  > 0u
NOS_EXT            OS_FLAG_GRP              *OSFlagDbgListPtr;
Xextern            OS_FLAG_GRP              *OSFlagDbgListPtr;
N#endif
NOS_EXT            OS_OBJ_QTY                OSFlagQty;
Xextern            OS_OBJ_QTY                OSFlagQty;
N#endif
N
N                                                                        /* MEMORY MANAGEMENT ------------------------ */
N#if OS_CFG_MEM_EN > 0u
X#if 1u > 0u
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
NOS_EXT            OS_MEM                   *OSMemDbgListPtr;
Xextern            OS_MEM                   *OSMemDbgListPtr;
N#endif
NOS_EXT            OS_OBJ_QTY                OSMemQty;                   /* Number of memory partitions created        */
Xextern            OS_OBJ_QTY                OSMemQty;
N#endif
N
N                                                                        /* OS_MSG POOL ------------------------------ */
N#if OS_MSG_EN > 0u
X#if (((1u > 0u) || (1u > 0u)) ? 1u : 0u) > 0u
NOS_EXT            OS_MSG_POOL               OSMsgPool;                  /* Pool of OS_MSG                             */
Xextern            OS_MSG_POOL               OSMsgPool;
N#endif
N
N                                                                        /* MUTEX MANAGEMENT ------------------------- */
N#if OS_CFG_MUTEX_EN > 0u
X#if 1u > 0u
N#if OS_CFG_DBG_EN   > 0u
X#if 1u   > 0u
NOS_EXT            OS_MUTEX                 *OSMutexDbgListPtr;
Xextern            OS_MUTEX                 *OSMutexDbgListPtr;
N#endif
NOS_EXT            OS_OBJ_QTY                OSMutexQty;                 /* Number of mutexes created                  */
Xextern            OS_OBJ_QTY                OSMutexQty;
N#endif
N
N                                                                        /* PRIORITIES ------------------------------- */
NOS_EXT            OS_PRIO                   OSPrioCur;                  /* Priority of current task                   */
Xextern            OS_PRIO                   OSPrioCur;
NOS_EXT            OS_PRIO                   OSPrioHighRdy;              /* Priority of highest priority task          */
Xextern            OS_PRIO                   OSPrioHighRdy;
NOS_EXT            OS_PRIO                   OSPrioSaved;                /* Saved priority level when Post Deferred    */
Xextern            OS_PRIO                   OSPrioSaved;
Nextern            CPU_DATA                  OSPrioTbl[OS_PRIO_TBL_SIZE];
Xextern            CPU_DATA                  OSPrioTbl[((64u - 1u) / ((4 * 8u)) + 1u)];
N
N                                                                        /* QUEUES ----------------------------------- */
N#if OS_CFG_Q_EN   > 0u
X#if 1u   > 0u
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
NOS_EXT            OS_Q                     *OSQDbgListPtr;
Xextern            OS_Q                     *OSQDbgListPtr;
N#endif
NOS_EXT            OS_OBJ_QTY                OSQQty;                     /* Number of message queues created           */
Xextern            OS_OBJ_QTY                OSQQty;
N#endif
N
N
N
N                                                                        /* READY LIST ------------------------------- */
NOS_EXT            OS_RDY_LIST               OSRdyList[OS_CFG_PRIO_MAX]; /* Table of tasks ready to run                */
Xextern            OS_RDY_LIST               OSRdyList[64u];
N
N
N#ifdef OS_SAFETY_CRITICAL_IEC61508
SOS_EXT            CPU_BOOLEAN               OSSafetyCriticalStartFlag;  /* Flag indicating that all init. done        */
N#endif
N                                                                        /* SCHEDULER -------------------------------- */
N#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u
X#if 0u > 0u
SOS_EXT            CPU_TS_TMR                OSSchedLockTimeBegin;       /* Scheduler lock time measurement            */
SOS_EXT            CPU_TS_TMR                OSSchedLockTimeMax;
SOS_EXT            CPU_TS_TMR                OSSchedLockTimeMaxCur;
N#endif
N
NOS_EXT            OS_NESTING_CTR            OSSchedLockNestingCtr;      /* Lock nesting level                         */
Xextern            OS_NESTING_CTR            OSSchedLockNestingCtr;
N#if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
X#if 0u > 0u
SOS_EXT            OS_TICK                   OSSchedRoundRobinDfltTimeQuanta;
SOS_EXT            CPU_BOOLEAN               OSSchedRoundRobinEn;        /* Enable/Disable round-robin scheduling      */
N#endif
N                                                                        /* SEMAPHORES ------------------------------- */
N#if OS_CFG_SEM_EN > 0u
X#if 1u > 0u
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
NOS_EXT            OS_SEM                   *OSSemDbgListPtr;
Xextern            OS_SEM                   *OSSemDbgListPtr;
N#endif
NOS_EXT            OS_OBJ_QTY                OSSemQty;                   /* Number of semaphores created               */
Xextern            OS_OBJ_QTY                OSSemQty;
N#endif
N
N                                                                        /* STATISTICS ------------------------------- */
N#if OS_CFG_STAT_TASK_EN > 0u
X#if 0u > 0u
SOS_EXT            CPU_BOOLEAN               OSStatResetFlag;            /* Force the reset of the computed statistics */
SOS_EXT            OS_CPU_USAGE              OSStatTaskCPUUsage;         /* CPU Usage in %                             */
SOS_EXT            OS_CPU_USAGE              OSStatTaskCPUUsageMax;      /* CPU Usage in % (Peak)                      */
SOS_EXT            OS_TICK                   OSStatTaskCtr;
SOS_EXT            OS_TICK                   OSStatTaskCtrMax;
SOS_EXT            OS_TICK                   OSStatTaskCtrRun;
SOS_EXT            CPU_BOOLEAN               OSStatTaskRdy;
SOS_EXT            OS_TCB                    OSStatTaskTCB;
SOS_EXT            CPU_TS                    OSStatTaskTimeMax;
N#endif
N
N                                                                        /* TASKS ------------------------------------ */
NOS_EXT            OS_CTX_SW_CTR             OSTaskCtxSwCtr;             /* Number of context switches                 */
Xextern            OS_CTX_SW_CTR             OSTaskCtxSwCtr;
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
NOS_EXT            OS_TCB                   *OSTaskDbgListPtr;
Xextern            OS_TCB                   *OSTaskDbgListPtr;
N#endif
NOS_EXT            OS_OBJ_QTY                OSTaskQty;                  /* Number of tasks created                    */
Xextern            OS_OBJ_QTY                OSTaskQty;
N
N#if OS_CFG_TASK_REG_TBL_SIZE > 0u
X#if 1u > 0u
NOS_EXT            OS_REG_ID                 OSTaskRegNextAvailID;       /* Next available Task Register ID            */
Xextern            OS_REG_ID                 OSTaskRegNextAvailID;
N#endif
N
N                                                                        /* TICK TASK -------------------------------- */
NOS_EXT            OS_TICK                   OSTickCtr;                  /* Cnts the #ticks since startup or last set  */
Xextern            OS_TICK                   OSTickCtr;
NOS_EXT            OS_TCB                    OSTickTaskTCB;
Xextern            OS_TCB                    OSTickTaskTCB;
NOS_EXT            CPU_TS                    OSTickTaskTimeMax;
Xextern            CPU_TS                    OSTickTaskTimeMax;
N
N
N#if OS_CFG_TMR_EN > 0u                                                  /* TIMERS ----------------------------------- */
X#if 1u > 0u
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
NOS_EXT            OS_TMR                   *OSTmrDbgListPtr;
Xextern            OS_TMR                   *OSTmrDbgListPtr;
N#endif
NOS_EXT            OS_OBJ_QTY                OSTmrQty;                   /* Number of timers created                   */
Xextern            OS_OBJ_QTY                OSTmrQty;
NOS_EXT            OS_TCB                    OSTmrTaskTCB;               /* TCB of timer task                          */
Xextern            OS_TCB                    OSTmrTaskTCB;
NOS_EXT            CPU_TS                    OSTmrTaskTimeMax;
Xextern            CPU_TS                    OSTmrTaskTimeMax;
NOS_EXT            OS_TICK                   OSTmrTickCtr;               /* Current time for the timers                */
Xextern            OS_TICK                   OSTmrTickCtr;
NOS_EXT            OS_CTR                    OSTmrUpdateCnt;             /* Counter for updating timers                */
Xextern            OS_CTR                    OSTmrUpdateCnt;
NOS_EXT            OS_CTR                    OSTmrUpdateCtr;
Xextern            OS_CTR                    OSTmrUpdateCtr;
N#endif
N
N                                                                        /* TCBs ------------------------------------- */
NOS_EXT            OS_TCB                   *OSTCBCurPtr;                /* Pointer to currently running TCB           */
Xextern            OS_TCB                   *OSTCBCurPtr;
NOS_EXT            OS_TCB                   *OSTCBHighRdyPtr;            /* Pointer to highest priority  TCB           */
Xextern            OS_TCB                   *OSTCBHighRdyPtr;
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                                                   E X T E R N A L S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
Nextern  CPU_STK     * const OSCfg_IdleTaskStkBasePtr;
Nextern  CPU_STK_SIZE  const OSCfg_IdleTaskStkLimit;
Nextern  CPU_STK_SIZE  const OSCfg_IdleTaskStkSize;
Nextern  CPU_INT32U    const OSCfg_IdleTaskStkSizeRAM;
N
Nextern  OS_INT_Q    * const OSCfg_IntQBasePtr;
Nextern  OS_OBJ_QTY    const OSCfg_IntQSize;
Nextern  CPU_INT32U    const OSCfg_IntQSizeRAM;
Nextern  CPU_STK     * const OSCfg_IntQTaskStkBasePtr;
Nextern  CPU_STK_SIZE  const OSCfg_IntQTaskStkLimit;
Nextern  CPU_STK_SIZE  const OSCfg_IntQTaskStkSize;
Nextern  CPU_INT32U    const OSCfg_IntQTaskStkSizeRAM;
N
Nextern  CPU_STK     * const OSCfg_ISRStkBasePtr;
Nextern  CPU_STK_SIZE  const OSCfg_ISRStkSize;
Nextern  CPU_INT32U    const OSCfg_ISRStkSizeRAM;
N
Nextern  OS_MSG_SIZE   const OSCfg_MsgPoolSize;
Nextern  CPU_INT32U    const OSCfg_MsgPoolSizeRAM;
Nextern  OS_MSG      * const OSCfg_MsgPoolBasePtr;
N
Nextern  OS_PRIO       const OSCfg_StatTaskPrio;
Nextern  OS_RATE_HZ    const OSCfg_StatTaskRate_Hz;
Nextern  CPU_STK     * const OSCfg_StatTaskStkBasePtr;
Nextern  CPU_STK_SIZE  const OSCfg_StatTaskStkLimit;
Nextern  CPU_STK_SIZE  const OSCfg_StatTaskStkSize;
Nextern  CPU_INT32U    const OSCfg_StatTaskStkSizeRAM;
N
Nextern  CPU_STK_SIZE  const OSCfg_StkSizeMin;
N
Nextern  OS_RATE_HZ    const OSCfg_TickRate_Hz;
Nextern  OS_PRIO       const OSCfg_TickTaskPrio;
Nextern  CPU_STK     * const OSCfg_TickTaskStkBasePtr;
Nextern  CPU_STK_SIZE  const OSCfg_TickTaskStkLimit;
Nextern  CPU_STK_SIZE  const OSCfg_TickTaskStkSize;
Nextern  CPU_INT32U    const OSCfg_TickTaskStkSizeRAM;
Nextern  OS_OBJ_QTY    const OSCfg_TickWheelSize;
Nextern  CPU_INT32U    const OSCfg_TickWheelSizeRAM;
N
Nextern  OS_PRIO       const OSCfg_TmrTaskPrio;
Nextern  OS_RATE_HZ    const OSCfg_TmrTaskRate_Hz;
Nextern  CPU_STK     * const OSCfg_TmrTaskStkBasePtr;
Nextern  CPU_STK_SIZE  const OSCfg_TmrTaskStkLimit;
Nextern  CPU_STK_SIZE  const OSCfg_TmrTaskStkSize;
Nextern  CPU_INT32U    const OSCfg_TmrTaskStkSizeRAM;
Nextern  OS_OBJ_QTY    const OSCfg_TmrWheelSize;
Nextern  CPU_INT32U    const OSCfg_TmrSizeRAM;
N
N
Nextern  CPU_STK        OSCfg_IdleTaskStk[];
N
N#if (OS_CFG_ISR_POST_DEFERRED_EN > 0u)
X#if (0u > 0u)
Sextern  CPU_STK        OSCfg_IntQTaskStk[];
Sextern  OS_INT_Q       OSCfg_IntQ[];
N#endif
N
Nextern  CPU_STK        OSCfg_ISRStk[];
N
N#if (OS_MSG_EN > 0u)
X#if ((((1u > 0u) || (1u > 0u)) ? 1u : 0u) > 0u)
Nextern  OS_MSG         OSCfg_MsgPool[];
N#endif
N
N#if (OS_CFG_STAT_TASK_EN > 0u)
X#if (0u > 0u)
Sextern  CPU_STK        OSCfg_StatTaskStk[];
N#endif
N
Nextern  CPU_STK        OSCfg_TickTaskStk[];
Nextern  OS_TICK_SPOKE  OSCfg_TickWheel[];
N
N#if (OS_CFG_TMR_EN > 0u)
X#if (1u > 0u)
Nextern  CPU_STK        OSCfg_TmrTaskStk[];
Nextern  OS_TMR_SPOKE   OSCfg_TmrWheel[];
N#endif
N
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                                        F U N C T I O N   P R O T O T Y P E S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
N/* ================================================================================================================== */
N/*                                                    EVENT FLAGS                                                     */
N/* ================================================================================================================== */
N
N#if OS_CFG_FLAG_EN > 0u
X#if 1u > 0u
N
Nvoid          OSFlagCreate              (OS_FLAG_GRP           *p_grp,
N                                         CPU_CHAR              *p_name,
N                                         OS_FLAGS               flags,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_FLAG_DEL_EN > 0u
X#if 1u > 0u
NOS_OBJ_QTY    OSFlagDel                 (OS_FLAG_GRP           *p_grp,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
NOS_FLAGS      OSFlagPend                (OS_FLAG_GRP           *p_grp,
N                                         OS_FLAGS               flags,
N                                         OS_TICK                timeout,
N                                         OS_OPT                 opt,
N                                         CPU_TS                *p_ts,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_FLAG_PEND_ABORT_EN > 0u
X#if 1u > 0u
NOS_OBJ_QTY    OSFlagPendAbort           (OS_FLAG_GRP           *p_grp,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
NOS_FLAGS      OSFlagPendGetFlagsRdy     (OS_ERR                *p_err);
N
NOS_FLAGS      OSFlagPost                (OS_FLAG_GRP           *p_grp,
N                                         OS_FLAGS               flags,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
Nvoid          OS_FlagClr                (OS_FLAG_GRP           *p_grp);
N
Nvoid          OS_FlagBlock              (OS_PEND_DATA          *p_pend_data,
N                                         OS_FLAG_GRP           *p_grp,
N                                         OS_FLAGS               flags,
N                                         OS_OPT                 opt,
N                                         OS_TICK                timeout);
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_FlagDbgListAdd         (OS_FLAG_GRP           *p_grp);
N
Nvoid          OS_FlagDbgListRemove      (OS_FLAG_GRP           *p_grp);
N#endif
N
Nvoid          OS_FlagInit               (OS_ERR                *p_err);
N
NOS_FLAGS      OS_FlagPost               (OS_FLAG_GRP           *p_grp,
N                                         OS_FLAGS               flags,
N                                         OS_OPT                 opt,
N                                         CPU_TS                 ts,
N                                         OS_ERR                *p_err);
N
Nvoid          OS_FlagTaskRdy            (OS_TCB                *p_tcb,
N                                         OS_FLAGS               flags_rdy,
N                                         CPU_TS                 ts);
N#endif
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                          FIXED SIZE MEMORY BLOCK MANAGEMENT                                        */
N/* ================================================================================================================== */
N
N#if OS_CFG_MEM_EN > 0u
X#if 1u > 0u
N
Nvoid          OSMemCreate               (OS_MEM                *p_mem,
N                                         CPU_CHAR              *p_name,
N                                         void                  *p_addr,
N                                         OS_MEM_QTY             n_blks,
N                                         OS_MEM_SIZE            blk_size,
N                                         OS_ERR                *p_err);
N
Nvoid         *OSMemGet                  (OS_MEM                *p_mem,
N                                         OS_ERR                *p_err);
N
Nvoid          OSMemPut                  (OS_MEM                *p_mem,
N                                         void                  *p_blk,
N                                         OS_ERR                *p_err);
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_MemDbgListAdd          (OS_MEM                *p_mem);
N#endif
N
Nvoid          OS_MemInit                (OS_ERR                *p_err);
N
N#endif
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                             MUTUAL EXCLUSION SEMAPHORES                                            */
N/* ================================================================================================================== */
N
N#if OS_CFG_MUTEX_EN > 0u
X#if 1u > 0u
N
Nvoid          OSMutexCreate             (OS_MUTEX              *p_mutex,
N                                         CPU_CHAR              *p_name,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_MUTEX_DEL_EN > 0u
X#if 1u > 0u
NOS_OBJ_QTY    OSMutexDel                (OS_MUTEX              *p_mutex,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
Nvoid          OSMutexPend               (OS_MUTEX              *p_mutex,
N                                         OS_TICK                timeout,
N                                         OS_OPT                 opt,
N                                         CPU_TS                *p_ts,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_MUTEX_PEND_ABORT_EN > 0u
X#if 1u > 0u
NOS_OBJ_QTY    OSMutexPendAbort          (OS_MUTEX              *p_mutex,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
Nvoid          OSMutexPost               (OS_MUTEX              *p_mutex,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
Nvoid          OS_MutexClr               (OS_MUTEX              *p_mutex);
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_MutexDbgListAdd        (OS_MUTEX              *p_mutex);
N
Nvoid          OS_MutexDbgListRemove     (OS_MUTEX              *p_mutex);
N#endif
N
Nvoid          OS_MutexInit              (OS_ERR                *p_err);
N#endif
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                                   MESSAGE QUEUES                                                   */
N/* ================================================================================================================== */
N
N#if OS_CFG_PEND_MULTI_EN > 0u
X#if 1u > 0u
N
NOS_OBJ_QTY    OSPendMulti               (OS_PEND_DATA          *p_pend_data_tbl,
N                                         OS_OBJ_QTY             tbl_size,
N                                         OS_TICK                timeout,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
NOS_OBJ_QTY    OS_PendMultiGetRdy        (OS_PEND_DATA          *p_pend_data_tbl,
N                                         OS_OBJ_QTY             tbl_size);
N
NCPU_BOOLEAN   OS_PendMultiValidate      (OS_PEND_DATA          *p_pend_data_tbl,
N                                         OS_OBJ_QTY             tbl_size);
N
Nvoid          OS_PendMultiWait          (OS_PEND_DATA          *p_pend_data_tbl,
N                                         OS_OBJ_QTY             tbl_size,
N                                         OS_TICK                timeout);
N#endif
N
N/* ================================================================================================================== */
N/*                                                   MESSAGE QUEUES                                                   */
N/* ================================================================================================================== */
N
N#if OS_CFG_Q_EN > 0u
X#if 1u > 0u
N
Nvoid          OSQCreate                 (OS_Q                  *p_q,
N                                         CPU_CHAR              *p_name,
N                                         OS_MSG_QTY             max_qty,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_Q_DEL_EN > 0u
X#if 1u > 0u
NOS_OBJ_QTY    OSQDel                    (OS_Q                  *p_q,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
N#if OS_CFG_Q_FLUSH_EN > 0u
X#if 1u > 0u
NOS_MSG_QTY    OSQFlush                  (OS_Q                  *p_q,
N                                         OS_ERR                *p_err);
N#endif
N
Nvoid         *OSQPend                   (OS_Q                  *p_q,
N                                         OS_TICK                timeout,
N                                         OS_OPT                 opt,
N                                         OS_MSG_SIZE           *p_msg_size,
N                                         CPU_TS                *p_ts,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_Q_PEND_ABORT_EN > 0u
X#if 1u > 0u
NOS_OBJ_QTY    OSQPendAbort              (OS_Q                  *p_q,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
Nvoid          OSQPost                   (OS_Q                  *p_q,
N                                         void                  *p_void,
N                                         OS_MSG_SIZE            msg_size,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
Nvoid          OS_QClr                   (OS_Q                  *p_q);
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_QDbgListAdd            (OS_Q                  *p_q);
N
Nvoid          OS_QDbgListRemove         (OS_Q                  *p_q);
N#endif
N
Nvoid          OS_QInit                  (OS_ERR                *p_err);
N
Nvoid          OS_QPost                  (OS_Q                  *p_q,
N                                         void                  *p_void,
N                                         OS_MSG_SIZE            msg_size,
N                                         OS_OPT                 opt,
N                                         CPU_TS                 ts,
N                                         OS_ERR                *p_err);
N#endif
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                                     SEMAPHORES                                                     */
N/* ================================================================================================================== */
N
N#if OS_CFG_SEM_EN > 0u
X#if 1u > 0u
N
Nvoid          OSSemCreate               (OS_SEM                *p_sem,
N                                         CPU_CHAR              *p_name,
N                                         OS_SEM_CTR             cnt,
N                                         OS_ERR                *p_err);
N
NOS_OBJ_QTY    OSSemDel                  (OS_SEM                *p_sem,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
NOS_SEM_CTR    OSSemPend                 (OS_SEM                *p_sem,
N                                         OS_TICK                timeout,
N                                         OS_OPT                 opt,
N                                         CPU_TS                *p_ts,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_SEM_PEND_ABORT_EN > 0u
X#if 1u > 0u
NOS_OBJ_QTY    OSSemPendAbort            (OS_SEM                *p_sem,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
NOS_SEM_CTR    OSSemPost                 (OS_SEM                *p_sem,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_SEM_SET_EN > 0u
X#if 1u > 0u
Nvoid          OSSemSet                  (OS_SEM                *p_sem,
N                                         OS_SEM_CTR             cnt,
N                                         OS_ERR                *p_err);
N#endif
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
Nvoid          OS_SemClr                 (OS_SEM                *p_sem);
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_SemDbgListAdd          (OS_SEM                *p_sem);
N
Nvoid          OS_SemDbgListRemove       (OS_SEM                *p_sem);
N#endif
N
Nvoid          OS_SemInit                (OS_ERR                *p_err);
N
NOS_SEM_CTR    OS_SemPost                (OS_SEM                *p_sem,
N                                         OS_OPT                 opt,
N                                         CPU_TS                 ts,
N                                         OS_ERR                *p_err);
N#endif
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                                 TASK MANAGEMENT                                                    */
N/* ================================================================================================================== */
N
N#if OS_CFG_TASK_CHANGE_PRIO_EN > 0u
X#if 1u > 0u
Nvoid          OSTaskChangePrio          (OS_TCB                *p_tcb,
N                                         OS_PRIO                prio_new,
N                                         OS_ERR                *p_err);
N#endif
N
Nvoid          OSTaskCreate              (OS_TCB                *p_tcb,
N                                         CPU_CHAR              *p_name,
N                                         OS_TASK_PTR            p_task,
N                                         void                  *p_arg,
N                                         OS_PRIO                prio,
N                                         CPU_STK               *p_stk_base,
N                                         CPU_STK_SIZE           stk_limit,
N                                         CPU_STK_SIZE           stk_size,
N                                         OS_MSG_QTY             q_size,
N                                         OS_TICK                time_quanta,
N                                         void                  *p_ext,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_TASK_DEL_EN > 0u
X#if 1u > 0u
Nvoid          OSTaskDel                 (OS_TCB                *p_tcb,
N                                         OS_ERR                *p_err);
N#endif
N
N#if OS_CFG_TASK_Q_EN > 0u
X#if 1u > 0u
NOS_MSG_QTY    OSTaskQFlush              (OS_TCB                *p_tcb,
N                                         OS_ERR                *p_err);
N
Nvoid         *OSTaskQPend               (OS_TICK                timeout,
N                                         OS_OPT                 opt,
N                                         OS_MSG_SIZE           *p_msg_size,
N                                         CPU_TS                *p_ts,
N                                         OS_ERR                *p_err);
N
NCPU_BOOLEAN   OSTaskQPendAbort          (OS_TCB                *p_tcb,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
Nvoid          OSTaskQPost               (OS_TCB                *p_tcb,
N                                         void                  *p_void,
N                                         OS_MSG_SIZE            msg_size,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
N#endif
N
N#if OS_CFG_TASK_REG_TBL_SIZE > 0u
X#if 1u > 0u
NOS_REG        OSTaskRegGet              (OS_TCB                *p_tcb,
N                                         OS_REG_ID              id,
N                                         OS_ERR                *p_err);
N
NOS_REG_ID     OSTaskRegGetID            (OS_ERR                *p_err);
N
Nvoid          OSTaskRegSet              (OS_TCB                *p_tcb,
N                                         OS_REG_ID              id,
N                                         OS_REG                 value,
N                                         OS_ERR                *p_err);
N#endif
N
N#if OS_CFG_TASK_SUSPEND_EN > 0u
X#if 1u > 0u
Nvoid          OSTaskResume              (OS_TCB                *p_tcb,
N                                         OS_ERR                *p_err);
N
Nvoid          OSTaskSuspend             (OS_TCB                *p_tcb,
N                                         OS_ERR                *p_err);
N#endif
N
NOS_SEM_CTR    OSTaskSemPend             (OS_TICK                timeout,
N                                         OS_OPT                 opt,
N                                         CPU_TS                *p_ts,
N                                         OS_ERR                *p_err);
N
N#if (OS_CFG_TASK_SEM_PEND_ABORT_EN > 0u)
X#if (1u > 0u)
NCPU_BOOLEAN   OSTaskSemPendAbort        (OS_TCB                *p_tcb,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
NOS_SEM_CTR    OSTaskSemPost             (OS_TCB                *p_tcb,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
NOS_SEM_CTR    OSTaskSemSet              (OS_TCB                *p_tcb,
N                                         OS_SEM_CTR             cnt,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_STAT_TASK_STK_CHK_EN > 0u
X#if 1u > 0u
Nvoid          OSTaskStkChk              (OS_TCB                *p_tcb,
N                                         CPU_STK_SIZE          *p_free,
N                                         CPU_STK_SIZE          *p_used,
N                                         OS_ERR                *p_err);
N#endif
N
N#if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
X#if 0u > 0u
Svoid          OSTaskTimeQuantaSet       (OS_TCB                *p_tcb,
S                                         OS_TICK                time_quanta,
S                                         OS_ERR                *p_err);
N#endif
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
Nvoid          OS_TaskBlock              (OS_TCB                *p_tcb,
N                                         OS_TICK                timeout);
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_TaskDbgListAdd         (OS_TCB                *p_tcb);
N
Nvoid          OS_TaskDbgListRemove      (OS_TCB                *p_tcb);
N#endif
N
Nvoid          OS_TaskInit               (OS_ERR                *p_err);
N
Nvoid          OS_TaskInitTCB            (OS_TCB                *p_tcb);
N
Nvoid          OS_TaskQPost              (OS_TCB                *p_tcb,
N                                         void                  *p_void,
N                                         OS_MSG_SIZE            msg_size,
N                                         OS_OPT                 opt,
N                                         CPU_TS                 ts,
N                                         OS_ERR                *p_err);
N
Nvoid          OS_TaskRdy                (OS_TCB                *p_tcb);
N
N#if OS_CFG_TASK_SUSPEND_EN > 0u
X#if 1u > 0u
Nvoid          OS_TaskResume             (OS_TCB                *p_tcb,
N                                         OS_ERR                *p_err);
N#endif
N
Nvoid          OS_TaskReturn             (void);
N
NOS_SEM_CTR    OS_TaskSemPost            (OS_TCB                *p_tcb,
N                                         OS_OPT                 opt,
N                                         CPU_TS                 ts,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_TASK_SUSPEND_EN > 0u
X#if 1u > 0u
Nvoid          OS_TaskSuspend            (OS_TCB                *p_tcb,
N                                         OS_ERR                *p_err);
N#endif
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                          TASK LOCAL STORAGE (TLS) SUPPORT                                          */
N/* ================================================================================================================== */
N
N#if defined(OS_CFG_TLS_TBL_SIZE) && (OS_CFG_TLS_TBL_SIZE > 0u)
X#if 0L && (OS_CFG_TLS_TBL_SIZE > 0u)
SOS_TLS_ID  OS_TLS_GetID       (OS_ERR              *p_err);
S
SOS_TLS     OS_TLS_GetValue    (OS_TCB              *p_tcb,
S                               OS_TLS_ID            id,
S                               OS_ERR              *p_err);
S
Svoid       OS_TLS_Init        (OS_ERR              *p_err);
S
Svoid       OS_TLS_SetValue    (OS_TCB              *p_tcb,
S                               OS_TLS_ID            id,
S                               OS_TLS               value,
S                               OS_ERR              *p_err);
S
Svoid       OS_TLS_SetDestruct (OS_TLS_ID            id,
S                               OS_TLS_DESTRUCT_PTR  p_destruct,
S                               OS_ERR              *p_err);
S
Svoid       OS_TLS_TaskCreate  (OS_TCB              *p_tcb);
S
Svoid       OS_TLS_TaskDel     (OS_TCB              *p_tcb);
S
Svoid       OS_TLS_TaskSw      (void);
N#endif
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                                 TIME MANAGEMENT                                                    */
N/* ================================================================================================================== */
N
Nvoid          OSTimeDly                 (OS_TICK                dly,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
N#if OS_CFG_TIME_DLY_HMSM_EN > 0u
X#if 1u > 0u
Nvoid          OSTimeDlyHMSM             (CPU_INT16U             hours,
N                                         CPU_INT16U             minutes,
N                                         CPU_INT16U             seconds,
N                                         CPU_INT32U             milli,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N#endif
N
N#if OS_CFG_TIME_DLY_RESUME_EN > 0u
X#if 1u > 0u
Nvoid          OSTimeDlyResume           (OS_TCB                *p_tcb,
N                                         OS_ERR                *p_err);
N#endif
N
NOS_TICK       OSTimeGet                 (OS_ERR                *p_err);
N
Nvoid          OSTimeSet                 (OS_TICK                ticks,
N                                         OS_ERR                *p_err);
N
Nvoid          OSTimeTick                (void);
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                                 TIMER MANAGEMENT                                                   */
N/* ================================================================================================================== */
N
N#if OS_CFG_TMR_EN > 0u
X#if 1u > 0u
Nvoid          OSTmrCreate               (OS_TMR                *p_tmr,
N                                         CPU_CHAR              *p_name,
N                                         OS_TICK                dly,
N                                         OS_TICK                period,
N                                         OS_OPT                 opt,
N                                         OS_TMR_CALLBACK_PTR    p_callback,
N                                         void                  *p_callback_arg,
N                                         OS_ERR                *p_err);
N
NCPU_BOOLEAN   OSTmrDel                  (OS_TMR                *p_tmr,
N                                         OS_ERR                *p_err);
N
NOS_TICK       OSTmrRemainGet            (OS_TMR                *p_tmr,
N                                         OS_ERR                *p_err);
N
NCPU_BOOLEAN   OSTmrStart                (OS_TMR                *p_tmr,
N                                         OS_ERR                *p_err);
N
NOS_STATE      OSTmrStateGet             (OS_TMR                *p_tmr,
N                                         OS_ERR                *p_err);
N
NCPU_BOOLEAN   OSTmrStop                 (OS_TMR                *p_tmr,
N                                         OS_OPT                 opt,
N                                         void                  *p_callback_arg,
N                                         OS_ERR                *p_err);
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
Nvoid          OS_TmrClr                 (OS_TMR                *p_tmr);
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_TmrDbgListAdd          (OS_TMR                *p_tmr);
N
Nvoid          OS_TmrDbgListRemove       (OS_TMR                *p_tmr);
N#endif
N
Nvoid          OS_TmrInit                (OS_ERR                *p_err);
N
Nvoid          OS_TmrLink                (OS_TMR                *p_tmr,
N                                         OS_OPT                 opt);
N
Nvoid          OS_TmrResetPeak           (void);
N
Nvoid          OS_TmrUnlink              (OS_TMR                *p_tmr);
N
Nvoid          OS_TmrTask                (void                  *p_arg);
N
N#endif
N
N/*$PAGE*/
N/* ================================================================================================================== */
N/*                                                    MISCELLANEOUS                                                   */
N/* ================================================================================================================== */
N
Nvoid          OSInit                    (OS_ERR                *p_err);
N
Nvoid          OSIntEnter                (void);
Nvoid          OSIntExit                 (void);
N
N#ifdef OS_SAFETY_CRITICAL_IEC61508
Svoid          OSSafetyCriticalStart     (void);
N#endif
N
N#if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
X#if 0u > 0u
Svoid          OSSchedRoundRobinCfg      (CPU_BOOLEAN            en,
S                                         OS_TICK                dflt_time_quanta,
S                                         OS_ERR                *p_err);
S
Svoid          OSSchedRoundRobinYield    (OS_ERR                *p_err);
S
N#endif
N
Nvoid          OSSched                   (void);
N
Nvoid          OSSchedLock               (OS_ERR                *p_err);
Nvoid          OSSchedUnlock             (OS_ERR                *p_err);
N
Nvoid          OSStart                   (OS_ERR                *p_err);
N
N#if OS_CFG_STAT_TASK_EN > 0u
X#if 0u > 0u
Svoid          OSStatReset               (OS_ERR                *p_err);
S
Svoid          OSStatTaskCPUUsageInit    (OS_ERR                *p_err);
N#endif
N
NCPU_INT16U    OSVersion                 (OS_ERR                *p_err);
N
N/* ------------------------------------------------ INTERNAL FUNCTIONS ---------------------------------------------- */
N
Nvoid          OS_IdleTask               (void                  *p_arg);
N
Nvoid          OS_IdleTaskInit           (OS_ERR                *p_err);
N
N#if OS_CFG_STAT_TASK_EN > 0u
X#if 0u > 0u
Svoid          OS_StatTask               (void                  *p_arg);
N#endif
N
Nvoid          OS_StatTaskInit           (OS_ERR                *p_err);
N
Nvoid          OS_TickTask               (void                  *p_arg);
Nvoid          OS_TickTaskInit           (OS_ERR                *p_err);
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                                    T A R G E T   S P E C I F I C   F U N C T I O N S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
Nvoid          OSInitHook                (void);
N
Nvoid          OSTaskCreateHook          (OS_TCB                *p_tcb);
Nvoid          OSTaskDelHook             (OS_TCB                *p_tcb);
N
Nvoid          OSIdleTaskHook            (void);
N
Nvoid          OSTaskReturnHook          (OS_TCB                *p_tcb);
N
Nvoid          OSStatTaskHook            (void);
N
NCPU_STK      *OSTaskStkInit             (OS_TASK_PTR            p_task,
N                                         void                  *p_arg,
N                                         CPU_STK               *p_stk_base,
N                                         CPU_STK               *p_stk_limit,
N                                         CPU_STK_SIZE           stk_size,
N                                         OS_OPT                 opt);
N
Nvoid          OSTaskSwHook              (void);
N
Nvoid          OSTimeTickHook            (void);
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N************************************************************************************************************************
N*                   u C / O S - I I I   I N T E R N A L   F U N C T I O N   P R O T O T Y P E S
N************************************************************************************************************************
N************************************************************************************************************************
N*/
N
Nvoid          OSCfg_Init                (void);
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_Dbg_Init               (void);
N#endif
N
N
N#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
X#if 0u > 0u
Svoid          OS_IntQTaskInit           (OS_ERR                *p_err);
S
Svoid          OS_IntQPost               (OS_OBJ_TYPE            type,
S                                         void                  *p_obj,
S                                         void                  *p_void,
S                                         OS_MSG_SIZE            msg_size,
S                                         OS_FLAGS               flags,
S                                         OS_OPT                 opt,
S                                         CPU_TS                 ts,
S                                         OS_ERR                *p_err);
S
Svoid          OS_IntQRePost             (void);
S
Svoid          OS_IntQTask               (void                  *p_arg);
N#endif
N
N/* ----------------------------------------------- MESSAGE MANAGEMENT ----------------------------------------------- */
N
Nvoid          OS_MsgPoolInit            (OS_ERR                *p_err);
N
NOS_MSG_QTY    OS_MsgQFreeAll            (OS_MSG_Q              *p_msg_q);
N
Nvoid         *OS_MsgQGet                (OS_MSG_Q              *p_msg_q,
N                                         OS_MSG_SIZE           *p_msg_size,
N                                         CPU_TS                *p_ts,
N                                         OS_ERR                *p_err);
N
Nvoid          OS_MsgQInit               (OS_MSG_Q              *p_msg_q,
N                                         OS_MSG_QTY             size);
N
Nvoid          OS_MsgQPut                (OS_MSG_Q              *p_msg_q,
N                                         void                  *p_void,
N                                         OS_MSG_SIZE            msg_size,
N                                         OS_OPT                 opt,
N                                         CPU_TS                 ts,
N                                         OS_ERR                *p_err);
N
N/* ---------------------------------------------- PEND/POST MANAGEMENT ---------------------------------------------- */
N
Nvoid          OS_Pend                   (OS_PEND_DATA          *p_pend_data,
N                                         OS_PEND_OBJ           *p_obj,
N                                         OS_STATE               pending_on,
N                                         OS_TICK                timeout);
N
Nvoid          OS_PendAbort              (OS_PEND_OBJ           *p_obj,
N                                         OS_TCB                *p_tcb,
N                                         CPU_TS                 ts);
N
Nvoid          OS_PendAbort1             (OS_PEND_OBJ           *p_obj,
N                                         OS_TCB                *p_tcb,
N                                         CPU_TS                 ts);
N
Nvoid          OS_PendObjDel             (OS_PEND_OBJ           *p_obj,
N                                         OS_TCB                *p_tcb,
N                                         CPU_TS                 ts);
N
Nvoid          OS_PendObjDel1            (OS_PEND_OBJ           *p_obj,
N                                         OS_TCB                *p_tcb,
N                                         CPU_TS                 ts);
N
Nvoid          OS_Post                   (OS_PEND_OBJ           *p_obj,
N                                         OS_TCB                *p_tcb,
N                                         void                  *p_void,
N                                         OS_MSG_SIZE            msg_size,
N                                         CPU_TS                 ts);
N
Nvoid          OS_Post1                  (OS_PEND_OBJ           *p_obj,
N                                         OS_TCB                *p_tcb,
N                                         void                  *p_void,
N                                         OS_MSG_SIZE            msg_size,
N                                         CPU_TS                 ts);
N
N/* ----------------------------------------------- PRIORITY MANAGEMENT ---------------------------------------------- */
N
Nvoid          OS_PrioInit               (void);
N
Nvoid          OS_PrioInsert             (OS_PRIO                prio);
N
Nvoid          OS_PrioRemove             (OS_PRIO                prio);
N
NOS_PRIO       OS_PrioGetHighest         (void);
N
N/* --------------------------------------------------- SCHEDULING --------------------------------------------------- */
N
N#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
X#if 0u > 0u
Svoid          OS_Sched0                 (void);
N#endif
N
N#if OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u
X#if 0u > 0u
Svoid          OS_SchedLockTimeMeasStart (void);
Svoid          OS_SchedLockTimeMeasStop  (void);
N#endif
N
N#if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
X#if 0u > 0u
Svoid          OS_SchedRoundRobin        (OS_RDY_LIST           *p_rdy_list);
N#endif
N
N/* --------------------------------------------- READY LIST MANAGEMENT ---------------------------------------------- */
N
Nvoid          OS_RdyListInit            (void);
N
Nvoid          OS_RdyListInsert          (OS_TCB                *p_tcb);
N
Nvoid          OS_RdyListInsertHead      (OS_TCB                *p_tcb);
N
Nvoid          OS_RdyListInsertTail      (OS_TCB                *p_tcb);
N
Nvoid          OS_RdyListMoveHeadToTail  (OS_RDY_LIST           *p_rdy_list);
N
Nvoid          OS_RdyListRemove          (OS_TCB                *p_tcb);
N
N/* ---------------------------------------------- PEND LIST MANAGEMENT ---------------------------------------------- */
N
Nvoid          OS_PendDataInit           (OS_TCB                *p_tcb,
N                                         OS_PEND_DATA          *p_pend_data_tbl,
N                                         OS_OBJ_QTY             tbl_size);
N
N#if OS_CFG_DBG_EN > 0u
X#if 1u > 0u
Nvoid          OS_PendDbgNameAdd         (OS_PEND_OBJ           *p_obj,
N                                         OS_TCB                *p_tcb);
N
Nvoid          OS_PendDbgNameRemove      (OS_PEND_OBJ           *p_obj,
N                                         OS_TCB                *p_tcb);
N#endif
N
NOS_PEND_LIST *OS_PendListGetPtr         (OS_PEND_OBJ           *p_obj);
N
Nvoid          OS_PendListInit           (OS_PEND_LIST          *p_pend_list);
N
Nvoid          OS_PendListInsertHead     (OS_PEND_LIST          *p_pend_list,
N                                         OS_PEND_DATA          *p_pend_data);
N
Nvoid          OS_PendListInsertPrio     (OS_PEND_LIST          *p_pend_list,
N                                         OS_PEND_DATA          *p_pend_data);
N
Nvoid          OS_PendListChangePrio     (OS_TCB                *p_tcb,
N                                         OS_PRIO                prio_new);
N
Nvoid          OS_PendListRemove         (OS_TCB                *p_tcb);
N
Nvoid          OS_PendListRemove1        (OS_PEND_LIST          *p_pend_list,
N                                         OS_PEND_DATA          *p_pend_data);
N
N/* ---------------------------------------------- TICK LIST MANAGEMENT ---------------------------------------------- */
N
Nvoid          OS_TickListInit           (void);
N
Nvoid          OS_TickListInsert         (OS_TCB                *p_tcb,
N                                         OS_TICK                time,
N                                         OS_OPT                 opt,
N                                         OS_ERR                *p_err);
N
Nvoid          OS_TickListRemove         (OS_TCB                *p_tcb);
N
Nvoid          OS_TickListResetPeak      (void);
N
Nvoid          OS_TickListUpdate         (void);
N
N/*$PAGE*/
N/*
N************************************************************************************************************************
N*                                          LOOK FOR MISSING #define CONSTANTS
N*
N* This section is used to generate ERROR messages at compile time if certain #define constants are
N* MISSING in OS_CFG.H.  This allows you to quickly determine the source of the error.
N*
N* You SHOULD NOT change this section UNLESS you would like to add more comments as to the source of the
N* compile time error.
N************************************************************************************************************************
N*/
N
N/*
N************************************************************************************************************************
N*                                                     MISCELLANEOUS
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_APP_HOOKS_EN
S#error  "OS_CFG.H, Missing OS_CFG_APP_HOOKS_EN: Enable (1) or Disable (0) application specific hook functions"
N#endif
N
N
N#ifndef OS_CFG_ARG_CHK_EN
S#error  "OS_CFG.H, Missing OS_CFG_ARG_CHK_EN: Enable (1) or Disable (0) argument checking"
N#endif
N
N
N#ifndef OS_CFG_DBG_EN
S#error  "OS_CFG.H, Missing OS_CFG_DBG_EN: Allows you to include variables for debugging or not"
N#endif
N
N
N#ifndef OS_CFG_CALLED_FROM_ISR_CHK_EN
S#error  "OS_CFG.H, Missing OS_CFG_CALLED_FROM_ISR_CHK_EN: Enable (1) or Disable (0) checking whether in an ISR in kernel services"
N#endif
N
N
N#ifndef OS_CFG_OBJ_TYPE_CHK_EN
S#error  "OS_CFG.H, Missing OS_CFG_OBJ_TYPE_CHK_EN: Enable (1) or Disable (0) checking for proper object types in kernel services"
N#endif
N
N
N#ifndef OS_CFG_PEND_MULTI_EN
S#error  "OS_CFG.H, Missing OS_CFG_PEND_MULTI_EN: Enable (1) or Disable (0) multi-pend feature"
N#endif
N
N
N#if     OS_CFG_PRIO_MAX < 8u
X#if     64u < 8u
S#error  "OS_CFG.H,         OS_CFG_PRIO_MAX must be >= 8"
N#endif
N
N
N#ifndef OS_CFG_SCHED_LOCK_TIME_MEAS_EN
S#error  "OS_CFG.H, Missing OS_CFG_SCHED_LOCK_TIME_MEAS_EN: Include code to measure scheduler lock time"
N#else
N    #if    (OS_CFG_SCHED_LOCK_TIME_MEAS_EN > 0u) && \
N           (OS_CFG_TS_EN                   < 1u)
X    #if    (0u > 0u) &&            (1u                   < 1u)
S    #error  "OS_CFG.H,         OS_CFG_TS_EN must be Enabled (1) to measure scheduler lock time"
N    #endif
N#endif
N
N
N#ifndef OS_CFG_SCHED_ROUND_ROBIN_EN
S#error  "OS_CFG.H, Missing OS_CFG_SCHED_ROUND_ROBIN_EN: Include code for Round Robin Scheduling"
N#endif
N
N
N#ifndef OS_CFG_STK_SIZE_MIN
S#error  "OS_CFG.H, Missing OS_CFG_STK_SIZE_MIN: Determines the minimum size for a task stack"
N#endif
N
N#ifndef OS_CFG_TS_EN
S#error  "OS_CFG.H, Missing OS_CFG_TS_EN: Determines whether time stamping is enabled"
N#else
N    #if    (OS_CFG_TS_EN  >  0u) && \
N           (CPU_CFG_TS_EN == DEF_DISABLED)
X    #if    (1u  >  0u) &&            (1u == 0u)
S    #error  "CPU_CFG.H,        CPU_CFG_TS_32_EN must be Enabled (1) to use time stamp feature"
N    #endif
N#endif
N
N/*
N************************************************************************************************************************
N*                                                     EVENT FLAGS
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_FLAG_EN
S#error  "OS_CFG.H, Missing OS_CFG_FLAG_EN: Enable (1) or Disable (0) code generation for Event Flags"
N#else
N    #ifndef OS_CFG_FLAG_DEL_EN
S    #error  "OS_CFG.H, Missing OS_CFG_FLAG_DEL_EN: Include code for OSFlagDel()"
N    #endif
N
N    #ifndef OS_CFG_FLAG_MODE_CLR_EN
S    #error  "OS_CFG.H, Missing OS_CFG_FLAG_MODE_CLR_EN: Include code for Wait on Clear EVENT FLAGS"
N    #endif
N
N    #ifndef OS_CFG_FLAG_PEND_ABORT_EN
S    #error  "OS_CFG.H, Missing OS_CFG_FLAG_PEND_ABORT_EN: Include code for aborting pends from another task"
N    #endif
N#endif
N
N/*
N************************************************************************************************************************
N*                                                  MEMORY MANAGEMENT
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_MEM_EN
S#error  "OS_CFG.H, Missing OS_CFG_MEM_EN: Enable (1) or Disable (0) code generation for MEMORY MANAGER"
N#endif
N
N/*
N************************************************************************************************************************
N*                                              MUTUAL EXCLUSION SEMAPHORES
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_MUTEX_EN
S#error  "OS_CFG.H, Missing OS_CFG_MUTEX_EN: Enable (1) or Disable (0) code generation for MUTEX"
N#else
N    #ifndef OS_CFG_MUTEX_DEL_EN
S    #error  "OS_CFG.H, Missing OS_CFG_MUTEX_DEL_EN: Include code for OSMutexDel()"
N    #endif
N
N    #ifndef OS_CFG_MUTEX_PEND_ABORT_EN
S    #error  "OS_CFG.H, Missing OS_CFG_MUTEX_PEND_ABORT_EN: Include code for OSMutexPendAbort()"
N    #endif
N#endif
N
N/*
N************************************************************************************************************************
N*                                                    MESSAGE QUEUES
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_Q_EN
S#error  "OS_CFG.H, Missing OS_CFG_Q_EN: Enable (1) or Disable (0) code generation for QUEUES"
N#else
N    #ifndef OS_CFG_Q_DEL_EN
S    #error  "OS_CFG.H, Missing OS_CFG_Q_DEL_EN: Include code for OSQDel()"
N    #endif
N
N    #ifndef OS_CFG_Q_FLUSH_EN
S    #error  "OS_CFG.H, Missing OS_CFG_Q_FLUSH_EN: Include code for OSQFlush()"
N    #endif
N
N    #ifndef OS_CFG_Q_PEND_ABORT_EN
S    #error  "OS_CFG.H, Missing OS_CFG_Q_PEND_ABORT_EN: Include code for OSQPendAbort()"
N    #endif
N#endif
N
N/*
N************************************************************************************************************************
N*                                                      SEMAPHORES
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_SEM_EN
S#error  "OS_CFG.H, Missing OS_CFG_SEM_EN: Enable (1) or Disable (0) code generation for SEMAPHORES"
N#else
N    #ifndef OS_CFG_SEM_DEL_EN
S    #error  "OS_CFG.H, Missing OS_CFG_SEM_DEL_EN: Include code for OSSemDel()"
N    #endif
N
N    #ifndef OS_CFG_SEM_PEND_ABORT_EN
S    #error  "OS_CFG.H, Missing OS_CFG_SEM_PEND_ABORT_EN: Include code for OSSemPendAbort()"
N    #endif
N
N    #ifndef OS_CFG_SEM_SET_EN
S    #error  "OS_CFG.H, Missing OS_CFG_SEM_SET_EN: Include code for OSSemSet()"
N    #endif
N#endif
N
N/*
N************************************************************************************************************************
N*                                                   TASK MANAGEMENT
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_STAT_TASK_EN
S#error  "OS_CFG.H, Missing OS_CFG_STAT_TASK_EN: Enable (1) or Disable(0) the statistics task"
N#endif
N
N#ifndef OS_CFG_STAT_TASK_STK_CHK_EN
S#error  "OS_CFG.H, Missing OS_CFG_STAT_TASK_STK_CHK_EN: Check task stacks from statistics task"
N#endif
N
N#ifndef OS_CFG_TASK_CHANGE_PRIO_EN
S#error  "OS_CFG.H, Missing OS_CFG_TASK_CHANGE_PRIO_EN: Include code for OSTaskChangePrio()"
N#endif
N
N#ifndef OS_CFG_TASK_DEL_EN
S#error  "OS_CFG.H, Missing OS_CFG_TASK_DEL_EN: Include code for OSTaskDel()"
N#endif
N
N#ifndef OS_CFG_TASK_Q_EN
S#error  "OS_CFG.H, Missing OS_CFG_TASK_Q_EN: Include code for OSTaskQxxx()"
N#endif
N
N#ifndef OS_CFG_TASK_Q_PEND_ABORT_EN
S#error  "OS_CFG.H, Missing OS_CFG_TASK_Q_PEND_ABORT_EN: Include code for OSTaskQPendAbort()"
N#endif
N
N#ifndef OS_CFG_TASK_PROFILE_EN
S#error  "OS_CFG.H, Missing OS_CFG_TASK_PROFILE_EN: Include code for task profiling"
N#endif
N
N#ifndef OS_CFG_TASK_REG_TBL_SIZE
S#error  "OS_CFG.H, Missing OS_CFG_TASK_REG_TBL_SIZE: Include support for task specific registers"
N#endif
N
N#ifndef OS_CFG_TASK_SEM_PEND_ABORT_EN
S#error  "OS_CFG.H, Missing OS_CFG_TASK_SEM_PEND_ABORT_EN: Include code for OSTaskSemPendAbort()"
N#endif
N
N#ifndef OS_CFG_TASK_SUSPEND_EN
S#error  "OS_CFG.H, Missing OS_CFG_TASK_SUSPEND_EN: Include code for OSTaskSuspend() and OSTaskResume()"
N#endif
N
N/*
N************************************************************************************************************************
N*                                                  TIME MANAGEMENT
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_TIME_DLY_HMSM_EN
S#error  "OS_CFG.H, Missing OS_CFG_TIME_DLY_HMSM_EN: Include code for OSTimeDlyHMSM()"
N#endif
N
N#ifndef OS_CFG_TIME_DLY_RESUME_EN
S#error  "OS_CFG.H, Missing OS_CFG_TIME_DLY_RESUME_EN: Include code for OSTimeDlyResume()"
N#endif
N
N/*
N************************************************************************************************************************
N*                                                  TIMER MANAGEMENT
N************************************************************************************************************************
N*/
N
N#ifndef OS_CFG_TMR_EN
S#error  "OS_CFG.H, Missing OS_CFG_TMR_EN: When (1) enables code generation for Timer Management"
N#else
N    #ifndef OS_CFG_TMR_DEL_EN
S    #error  "OS_CFG.H, Missing OS_CFG_TMR_DEL_EN: Enables (1) or Disables (0) code for OSTmrDel()"
N    #endif
N#endif
N
N/*
N************************************************************************************************************************
N*                                             LIBRARY CONFIGURATION ERRORS
N************************************************************************************************************************
N*/
N
N                                                                /* See 'os.h  Note #1a'.                              */
N#if LIB_VERSION < 126u
X#if 13700u < 126u
S#error  "lib_def.h, LIB_VERSION SHOULD be >= V1.26"
N#endif
N
N
N                                                                /* See 'os.h  Note #1b'.                              */
N#if CPU_CORE_VERSION < 125u
X#if 12901u < 125u
S#error  "cpu_core.h, CPU_CORE_VERSION SHOULD be >= V1.25"
N#endif
N
N
N/*
N************************************************************************************************************************
N*                                                 uC/OS-III MODULE END
N************************************************************************************************************************
N*/
N
N#ifdef __cplusplus
S}
N#endif
N#endif
L 23 "..\..\RL-ARM\Config\Net_lib.c" 2
N#endif
N
N/* Non-Critical Net_Config.c upgrade */
N#ifndef HTTP_SRVID
S #define HTTP_SRVID     ""
N#endif
N#ifndef FTP_WELMSG
S #define FTP_WELMSG     ""
N#endif
N#ifndef DHCP_VCID
S #define DHCP_VCID      ""
N#endif
N#ifndef DHCP_BOOTF
S #define DHCP_BOOTF     0
N#endif
N#ifndef DHCP_NTPSRV
S #define DHCP_NTPSRV    0
N#endif
N#ifndef TNET_NOECHO
S #define TNET_NOECHO    0
N#endif
N#ifndef TFTP_ENFWALL
S #define TFTP_ENFWALL   0
N#endif
N#ifndef TCP_MAXSEGSZ
S #define TCP_MAXSEGSZ   1460
N#endif
N#ifndef TCP_RECWINSZ
S #define TCP_RECWINSZ   TCP_DEF_WINSIZE
N#endif
N
N#define TICK_RATE       (1000 / TICK_INTERVAL)
N
N/* Some configuration error checking. */
N#if !(SLIP_ENABLE || PPP_ENABLE || ETH_ENABLE)
X#if !(0 || 0 || 1)
S #error All network interfaces disabled in configuration
N#endif
N
N#if (SLIP_ENABLE && PPP_ENABLE)
X#if (0 && 0)
S #error Both SLIP and PPP interfaces enabled
N#endif
N
N/* Check TCP Socket enable. */
N#if (!TCP_ENABLE & (BSD_ENABLE | HTTP_ENABLE | TNET_ENABLE | FTP_ENABLE | \
N                    FTPC_ENABLE | SMTP_ENABLE))
X#if (!1 & (1 | 0 | 0 | 0 |                     0 | 0))
S #error Application needs TCP Sockets enabled
N#endif
N
N/* Check UDP Socket enable */
N#if (!UDP_ENABLE & (BSD_ENABLE | TFTP_ENABLE | DNS_ENABLE | SNMP_ENABLE | \
N                    SNTP_ENABLE | ((DHCP_ENABLE | NBNS_ENABLE) & ETH_ENABLE)))
X#if (!1 & (1 | 0 | 0 | 0 |                     0 | ((0 | 1) & 1)))
S #error Application needs UDP Sockets enabled
N#endif
N
N/* Check number of TCP sockets available. */
N#define __TCPNS    ((BSD_ENABLE  * BSD_NUMSOCKS)   + \
N                    (HTTP_ENABLE * HTTP_NUMSESS)   + \
N                    (TNET_ENABLE * TNET_NUMSESS)   + \
N                    (FTP_ENABLE  * FTP_NUMSESS*2)  + \
N                    (FTPC_ENABLE * 2)              + \
N                    (SMTP_ENABLE * 1))
X#define __TCPNS    ((BSD_ENABLE  * BSD_NUMSOCKS)   +                     (HTTP_ENABLE * HTTP_NUMSESS)   +                     (TNET_ENABLE * TNET_NUMSESS)   +                     (FTP_ENABLE  * FTP_NUMSESS*2)  +                     (FTPC_ENABLE * 2)              +                     (SMTP_ENABLE * 1))
N
N#if (__TCPNS > TCP_NUMSOCKS)
X#if (((1 * 2) + (0 * 5) + (0 * 2) + (0 * 3*2) + (0 * 2) + (0 * 1)) > 5)
S #error Number of TCP Sockets too small
N#endif
N
N/* Calculate number of UDP sockets needed for TFTP server. */
N#if (TFTP_ENFWALL)
X#if (0)
S #define __TFTP_NSOCKS  1
N#else
N #define __TFTP_NSOCKS  (1 + TFTP_NUMSESS)
N#endif
N
N/* Check number of UDP sockets available. */
N#define __UDPNS    ((BSD_ENABLE  * BSD_NUMSOCKS)   + \
N                    (TFTP_ENABLE * __TFTP_NSOCKS)  + \
N                    (TFTPC_ENABLE* 1)              + \
N                    (DNS_ENABLE  * 1)              + \
N                    (SNMP_ENABLE * 1)              + \
N                    (SNTP_ENABLE * 1)              + \
N                    (DHCP_ENABLE * ETH_ENABLE)     + \
N                    (NBNS_ENABLE * ETH_ENABLE))
X#define __UDPNS    ((BSD_ENABLE  * BSD_NUMSOCKS)   +                     (TFTP_ENABLE * __TFTP_NSOCKS)  +                     (TFTPC_ENABLE* 1)              +                     (DNS_ENABLE  * 1)              +                     (SNMP_ENABLE * 1)              +                     (SNTP_ENABLE * 1)              +                     (DHCP_ENABLE * ETH_ENABLE)     +                     (NBNS_ENABLE * ETH_ENABLE))
N
N#if (__UDPNS > UDP_NUMSOCKS)
X#if (((1 * 2) + (0 * (1 + 1)) + (0* 1) + (0 * 1) + (0 * 1) + (0 * 1) + (0 * 1) + (1 * 1)) > 5)
S #error Number of UDP Sockets too small
N#endif
N
N/* Check BSD Server sockets */
N#if (BSD_ENABLE && (BSD_SRVSOCKS > BSD_NUMSOCKS))
X#if (1 && (1 > 2))
S #error Number of BSD Server sockets too large
N#endif
N
N/* Check BSD Hostname resolver */
N#if (BSD_ENABLE && BSD_GETHOSTEN && !DNS_ENABLE)
X#if (1 && 0 && !0)
S #error BSD Hostname resolver needs DNS enabled
N#endif
N
N/* Check PPP Authentication protocols */
N#if (PPP_ENABLE && PPP_AUTHEN && !(PPP_PAPEN | PPP_CHAPEN))
X#if (0 && 1 && !(1 | 1))
S #error PPP Authentication needs PAP or/and CHAP enabled
N#endif
N
N/* Check Net_Config.c version */
N#if (TNET_ENABLE && !defined(TNET_IDLETOUT))                     || \
N    (FTP_ENABLE  && !defined(FTP_IDLETOUT))                      || \
N    (PPP_ENABLE  && (defined(_ACCM1) || defined(LCP_MAXRETRY)))
X#if (0 && !1L)                     ||     (0  && !1L)                      ||     (0  && (0L || 0L))
S #error Net_Config.c too old, needs update
N#endif
N
N/* Check Maximum Segment Size of TCP Socket */
N#if (TCP_ENABLE && ((TCP_MAXSEGSZ < 536) || (TCP_MAXSEGSZ > 1460)))
X#if (1 && ((1460 < 536) || (1460 > 1460)))
S #error TCP Maximum Segment Size out of range
N#endif
N
N/* Check Receive Window Size of TCP Socket */
N#if (TCP_ENABLE && (TCP_RECWINSZ < TCP_MAXSEGSZ))
X#if (1 && (4380 < 1460))
S #error TCP Receive Window Size too small
N#endif
N
N/* Check Block Size of TFTP Server */
N#if (TFTPC_ENABLE && ((TFTPC_BLOCKSZ < 128) || (TFTPC_BLOCKSZ > 1428)))
X#if (0 && ((512 < 128) || (512 > 1428)))
S #error TFTP Client Block Size out of range
N#endif
N
N/* Local Machine info */
NLOCALM const nlocalm[3] = {
N /* Ethernet: Local IP address */
N#if (ETH_ENABLE)
X#if (1)
N {{_IP1,_IP2,_IP3,_IP4},
X {{192,168,0,30},
N  /* Default Gateway IP address */
N  {_GW1,_GW2,_GW3,_GW4},
X  {192,168,0,1},
N  /* Subnet IP Mask */
N  {_MSK1,_MSK2,_MSK3,_MSK4},
X  {255,255,255,0},
N  /* Primary DNS Server IP */
N  {_pDNS1,_pDNS2,_pDNS3,_pDNS4},
X  {194,25,2,129},
N  /* Secondary DNS Server IP */
N  {_sDNS1,_sDNS2,_sDNS3,_sDNS4}},
X  {194,25,2,130}},
N#else
S {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}},
N#endif
N /* PPP: Local IP address */
N#if (PPP_ENABLE)
X#if (0)
S {{_IP1P,_IP2P,_IP3P,_IP4P},
S  /* Default Gateway IP address */
S  {0,0,0,0},
S  /* Subnet IP Mask */
S  {_MSK1P,_MSK2P,_MSK3P,_MSK4P},
S  /* Primary DNS Server IP */
S  {_pDNS1P,_pDNS2P,_pDNS3P,_pDNS4P},
S  /* Secondary DNS Server IP */
S  {_sDNS1P,_sDNS2P,_sDNS3P,_sDNS4P}},
N#else
N {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}},
N#endif
N /* SLIP: Local IP address */
N#if (SLIP_ENABLE)
X#if (0)
S {{_IP1S,_IP2S,_IP3S,_IP4S},
S  /* Default Gateway IP address */
S  {0,0,0,0},
S  /* Subnet IP Mask */
S  {_MSK1S,_MSK2S,_MSK3S,_MSK4S},
S  /* Primary DNS Server IP */
S  {_pDNS1S,_pDNS2S,_pDNS3S,_pDNS4S},
S  /* Secondary DNS Server IP */
S  {_sDNS1S,_sDNS2S,_sDNS3S,_sDNS4S}}
N#else
N {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}},
N#endif
N};
N/* System configuration */
Nstatic U32 mem_pool[MEM_SIZE];
Xstatic U32 mem_pool[2048];
N       U8  lhost_name[16] = LHOST_NAME;
X       U8  lhost_name[16] = "armfly";
NSYS_CFG sys_config = {
N  mem_pool,
N  sizeof (mem_pool),
N  TICK_RATE,
X  (1000 / 10),
N  TICK_INTERVAL,
X  10,
N  TICK_RATE / 5,
X  (1000 / 10) / 5,
N  (PPP_GETIP<<5   | SLIP_DEFGW<<4 | PPP_DEFGW<<3 |
X  (1<<5   | 1<<4 | 1<<3 |
N   SLIP_ENABLE<<2 | PPP_ENABLE<<1 | ETH_ENABLE),
X   0<<2 | 0<<1 | 1),
N  lhost_name
N};
N/* Ethernet network interface */
N#if (ETH_ENABLE)
X#if (1)
N static ARP_INFO arp_table[ARP_TABSIZE];
X static ARP_INFO arp_table[10];
N U8     own_hw_adr[ETH_ADRLEN] = {_MAC1,_MAC2,_MAC3,_MAC4,_MAC5,_MAC6};
X U8     own_hw_adr[6] = {0x1E,0x30,0x6C,0xA2,0x45,0x30};
N ARP_CFG arp_config = {
N   arp_table,
N   ARP_TABSIZE,
X   10,
N   ARP_TIMEOUT,
X   150,
N   ARP_MAXRETRY,
X   4,
N   ARP_RESEND,
X   2,
N   ARP_NOTIFY
X   0
N };
N#endif
N#if (PPP_ENABLE)
X#if (0)
S PPP_CFG ppp_config = {
S   PPP_ACCM,
S   5 * TICK_RATE,
S   PPP_RETRYTOUT * TICK_RATE,
S   PPP_ECHOTOUT,
S   PPP_MAXRETRY,
S   ((PPP_CHAPEN << 1) | PPP_PAPEN) * PPP_AUTHEN
S };
N#endif
N#if (SLIP_ENABLE)
X#if (0)
S U16 const slip_SerTout  = 5 * TICK_RATE;
N#endif
N#if (ETH_ENABLE && IGMP_ENABLE)
X#if (1 && 0)
S static IGMP_INFO igmp_table[IGMP_TABSIZE];
S IGMP_CFG  igmp_config = {
S   igmp_table,
S   IGMP_TABSIZE,
S };
N#endif
N#if (ETH_ENABLE && DHCP_ENABLE)
X#if (1 && 0)
S DHCP_CFG dhcp_config = {
S   DHCP_VCID,
S   (DHCP_NTPSRV << 1) | DHCP_BOOTF
S };
N#endif
N#if (UDP_ENABLE)
X#if (1)
N static UDP_INFO udp_scb[UDP_NUMSOCKS];
X static UDP_INFO udp_scb[5];
N UDP_CFG udp_config = {
N   udp_scb,
N   UDP_NUMSOCKS,
X   5,
N };
N#endif
N#if (TCP_ENABLE)
X#if (1)
N static TCP_INFO tcp_scb[TCP_NUMSOCKS];
X static TCP_INFO tcp_scb[5];
N TCP_CFG tcp_config = {
N   tcp_scb,
N   TCP_NUMSOCKS,
X   5,
N   TCP_MAXRETRY,
X   5,
N   TCP_RETRYTOUT * TICK_RATE,
X   4 * (1000 / 10),
N   (200 + TICK_INTERVAL - 1) / TICK_INTERVAL,
X   (200 + 10 - 1) / 10,
N   TCP_SYN_RETRY_TOUT * TICK_RATE,
X   2 * (1000 / 10),
N   TCP_INIT_RETRY_TOUT * TICK_RATE,
X   1 * (1000 / 10),
N   TCP_DEFTOUT,
X   4,
N   TCP_MAXSEGSZ,
X   1460,
N   TCP_RECWINSZ,
X   4380,
N   TCP_CONRETRY
X   7
N };
N#endif
N#if (HTTP_ENABLE)
X#if (0)
S static HTTP_INFO http_scb[HTTP_NUMSESS];
S static U8 http_passw[PASSW_SZ] = HTTP_AUTHPASSW;
S HTTP_CFG  http_config = {
S   http_scb,
S   HTTP_NUMSESS,
S   HTTP_ENAUTH,
S   HTTP_PORTNUM,
S   HTTP_SRVID,
S #if (HTTP_ENAUTH)
S   HTTP_AUTHREALM,
S   HTTP_AUTHUSER,
S   http_passw
S #else
S   "","",""
S #endif
S };
N#endif
N#if (TNET_ENABLE)
X#if (0)
S static TNET_INFO tnet_scb[TNET_NUMSESS];
S static U8 tnet_passw[PASSW_SZ] = TNET_AUTHPASSW;
S TNET_CFG  tnet_config = {
S   tnet_scb,
S   TNET_NUMSESS,
S   TNET_ENAUTH,
S   TNET_NOECHO,
S   TNET_PORTNUM,
S   TNET_IDLETOUT,
S #if (TNET_ENAUTH)
S   TNET_AUTHUSER,
S   tnet_passw
S #else
S   "",""
S #endif
S };
N#endif
N#if (TFTP_ENABLE)
X#if (0)
S static TFTP_INFO tftp_scb[TFTP_NUMSESS];
S TFTP_CFG tftp_config = {
S   &tftp_scb[0],
S   TFTP_NUMSESS,
S   TFTP_MAXRETRY,
S   TFTP_PORTNUM,
S   TFTP_DEFTOUT,
S   TFTP_ENFWALL
S };
N#endif
N#if (TFTPC_ENABLE)
X#if (0)
S TFTPC_CFG tftpc_config = {
S   TFTPC_BLOCKSZ,
S   (TFTPC_RETRYTO * TICK_RATE + 5) / 10,
S   TFTPC_MAXRETRY
S };
N#endif
N#if (FTP_ENABLE)
X#if (0)
S static FTP_INFO ftp_scb[FTP_NUMSESS];
S static U8 ftp_passw[PASSW_SZ] = FTP_AUTHPASSW;
S #define _LS(s)  sizeof(s)-1,s
S FTP_CFG ftp_config = {
S   ftp_scb,
S   FTP_NUMSESS,
S   FTP_ENAUTH,
S   FTP_PORTNUM,
S   FTP_IDLETOUT,
S  _LS(FTP_WELMSG),
S #if (FTP_ENAUTH)
S   FTP_AUTHUSER,
S   ftp_passw
S #else
S   "",""
S #endif
S };
N#endif
N#if (FTPC_ENABLE)
X#if (0)
S FTPC_CFG ftpc_config = {
S   FTPC_DEFTOUT,
S   FTPC_PASVMODE
S };
N#endif
N#if (DNS_ENABLE)
X#if (0)
S static DNS_CACHE dns_table[DNS_TABSIZE];
SDNS_CFG dns_config = {
S   dns_table,
S   DNS_TABSIZE
S };
N#endif
N#if (SMTP_ENABLE)
X#if (0)
S U8 const smtp_DefTout = SMTP_DEFTOUT;
N#endif
N#if (SNMP_ENABLE)
X#if (0)
S SNMP_CFG snmp_config = {
S   SNMP_PORTNUM,
S   SNMP_TRAPPORT,
S   { SNMP_TRAPIP1, SNMP_TRAPIP2, SNMP_TRAPIP3, SNMP_TRAPIP4 },
S   SNMP_COMMUNITY,
S   TICK_INTERVAL / 5
S };
N#endif
N#if (SNTP_ENABLE)
X#if (0)
S SNTP_CFG sntp_config = {
S { SNTP_SRVIP1, SNTP_SRVIP2, SNTP_SRVIP3, SNTP_SRVIP4 },
S SNTP_BCMODE
S };
N#endif
N#if (BSD_ENABLE)
X#if (1)
N static BSD_INFO bsd_scb[BSD_NUMSOCKS + BSD_SRVSOCKS];
X static BSD_INFO bsd_scb[2 + 1];
N #ifdef __RTX
N   OS_MUTEX  bsd_mutex;
N   OS_SEM    bsd_sem;
N  #define BSD_INRTX  __TRUE
N #else
S  #define BSD_INRTX  __FALSE
N #endif
N BSD_CFG bsd_config = {
N   bsd_scb,
N   BSD_NUMSOCKS + BSD_SRVSOCKS,
X   2 + 1,
N   BSD_INRTX,
X   1,
N   BSD_RCVTOUT * TICK_RATE
X   20 * (1000 / 10)
N };
N#endif
N
N/*----------------------------------------------------------------------------
N *      Library Interface
N *---------------------------------------------------------------------------*/
N
N
N/*--------------------------- init_system -----------------------------------*/
N
Nvoid init_system (void) {
N  /* Initialize configured interfaces and applications. */
N
N#if (ETH_ENABLE)
X#if (1)
N  eth_init_link ();
N#endif
N#if (PPP_ENABLE)
X#if (0)
S  ppp_init_link ();
N#endif
N#if (SLIP_ENABLE)
X#if (0)
S  slip_init_link ();
N#endif
N  ip_init ();
N  icmp_init ();
N#if (ETH_ENABLE && IGMP_ENABLE)
X#if (1 && 0)
S  igmp_init ();
N#endif
N#if (UDP_ENABLE)
X#if (1)
N  udp_init ();
N#endif
N#if (TCP_ENABLE)
X#if (1)
N  tcp_init ();
N#endif
N#if (BSD_ENABLE)
X#if (1)
N  bsd_init ();
N #if (BSD_GETHOSTEN)
X #if (0)
S  bsd_init_host ();
N #endif
N#endif
N#if (HTTP_ENABLE)
X#if (0)
S  http_init ();
N#endif
N#if (TNET_ENABLE)
X#if (0)
S  tnet_init ();
N#endif
N#if (TFTP_ENABLE)
X#if (0)
S  tftp_init ();
N#endif
N#if (TFTPC_ENABLE)
X#if (0)
S  tftpc_init ();
N#endif
N#if (FTP_ENABLE)
X#if (0)
S  ftp_init ();
N#endif
N#if (FTPC_ENABLE)
X#if (0)
S  ftpc_init ();
N#endif
N#if (ETH_ENABLE && NBNS_ENABLE)
X#if (1 && 1)
N  nbns_init ();
N#endif
N#if (ETH_ENABLE && DHCP_ENABLE)
X#if (1 && 0)
S  dhcp_init ();
N#elif (ETH_ENABLE)
X#elif (1)
N  arp_notify ();
N#endif
N#if (DNS_ENABLE)
X#if (0)
S  dns_init ();
N#endif
N#if (SMTP_ENABLE)
X#if (0)
S  smtp_init ();
N#endif
N#if (SNMP_ENABLE)
X#if (0)
S  snmp_init ();
N#endif
N#if (SNTP_ENABLE)
X#if (0)
S  sntp_init ();
N#endif
N
N#if (BSD_ENABLE && __RTX)
X#if (1 && 1)
N {
N	OS_ERR err;
N	OSMutexCreate(&bsd_mutex,
N				  "BSD Mutex",
N				   &err);
N
N	OSSemCreate((OS_SEM    *)&bsd_sem,
N				(CPU_CHAR  *)"BSD Sem",
N				(OS_SEM_CTR )0,
N				(OS_ERR    *)&err);
N }
N#endif
N}
N
N
N/*--------------------------- run_system ------------------------------------*/
N
Nvoid run_system (void) {
N  /* Run configured interfaces and applications. */
N
N#if (BSD_ENABLE && __RTX)
X#if (1 && 1)
N  OS_ERR err;
N  OSMutexPend((OS_MUTEX *)&bsd_mutex,
N			  (OS_TICK    )0,
N			  (OS_OPT     )OS_OPT_PEND_BLOCKING,
X			  (OS_OPT     )(OS_OPT)(0x0000u),
N			  (CPU_TS     )0,
N			  (OS_ERR    *)&err);
N#endif
N
N#if (ETH_ENABLE)
X#if (1)
N  eth_run_link ();
N#endif
N#if (PPP_ENABLE)
X#if (0)
S  ppp_run_link ();
N#endif
N#if (SLIP_ENABLE)
X#if (0)
S  slip_run_link ();
N#endif
N  ip_run_local ();
N  icmp_run_engine ();
N#if (ETH_ENABLE && IGMP_ENABLE)
X#if (1 && 0)
S  igmp_run_host ();
N#endif
N#if (TCP_ENABLE)
X#if (1)
N  tcp_poll_sockets ();
N#endif
N#if (BSD_ENABLE)
X#if (1)
N  bsd_poll_sockets ();
N#endif
N#if (HTTP_ENABLE)
X#if (0)
S  http_run_server ();
N#endif
N#if (TNET_ENABLE)
X#if (0)
S  tnet_run_server ();
N#endif
N#if (TFTP_ENABLE)
X#if (0)
S  tftp_run_server ();
N#endif
N#if (TFTPC_ENABLE)
X#if (0)
S  tftpc_run_client ();
N#endif
N#if (FTP_ENABLE)
X#if (0)
S  ftp_run_server ();
N#endif
N#if (FTPC_ENABLE)
X#if (0)
S  ftpc_run_client ();
N#endif
N#if (ETH_ENABLE && DHCP_ENABLE)
X#if (1 && 0)
S  dhcp_run_client ();
N#endif
N#if (DNS_ENABLE)
X#if (0)
S  dns_run_client ();
N#endif
N#if (SMTP_ENABLE)
X#if (0)
S  smtp_run_client ();
N#endif
N#if (SNMP_ENABLE)
X#if (0)
S  snmp_run_agent ();
N#endif
N#if (SNTP_ENABLE)
X#if (0)
S  sntp_run_client ();
N#endif
N
N#if (BSD_ENABLE && __RTX)
X#if (1 && 1)
N  OSMutexPost((OS_MUTEX *)&bsd_mutex,
N			  (OS_OPT     )OS_OPT_POST_1,
X			  (OS_OPT     )(OS_OPT)(0x0000u),
N			  (OS_ERR    *)&err);
N#endif
N}
N
N
N/*--------------------------- bsd_suspend/resume ----------------------------*/
N
N#if (BSD_ENABLE && __RTX)
X#if (1 && 1)
N__used void bsd_suspend (U8 *tsk_id) {
X__attribute__((used)) void bsd_suspend (U8 *tsk_id) {
N  	OS_ERR err;
N
N  /* Suspend a socket owner task. */
N  OSMutexPost((OS_MUTEX *)&bsd_mutex,
N			  (OS_OPT     )OS_OPT_POST_1,
X			  (OS_OPT     )(OS_OPT)(0x0000u),
N			  (OS_ERR    *)&err);
N
N  OSSemPend((OS_SEM *)&bsd_sem,
N			(OS_TICK )0,
N			(OS_OPT  )OS_OPT_PEND_BLOCKING,
X			(OS_OPT  )(OS_OPT)(0x0000u),
N			(CPU_TS  )0,
N			(OS_ERR *)&err);
N
N  OSMutexPend((OS_MUTEX *)&bsd_mutex,
N			  (OS_TICK    )0,
N			  (OS_OPT     )OS_OPT_PEND_BLOCKING,
X			  (OS_OPT     )(OS_OPT)(0x0000u),
N			  (CPU_TS     )0,
N			  (OS_ERR    *)&err);
N}
N
N__used void bsd_resume (U8 tsk_id) {
X__attribute__((used)) void bsd_resume (U8 tsk_id) {
N  /* Resume a task waiting for a socket event. */
N  OS_ERR err;
N
N  OSSemPost((OS_SEM *)&bsd_sem,
N	        (OS_OPT  )OS_OPT_POST_1,
X	        (OS_OPT  )(OS_OPT)(0x0000u),
N	        (OS_ERR *)&err);
N}
N#endif
N
N
N/*--------------------------- bsd_lock/unlock -------------------------------*/
N
N#if (BSD_ENABLE && __RTX)
X#if (1 && 1)
N__used void bsd_lock (void) {
X__attribute__((used)) void bsd_lock (void) {
N  /* Acquire mutex - Lock TCPnet functions. */
N  OS_ERR err;
N
N  OSMutexPend((OS_MUTEX *)&bsd_mutex,
N			  (OS_TICK    )0,
N			  (OS_OPT     )OS_OPT_PEND_BLOCKING,
X			  (OS_OPT     )(OS_OPT)(0x0000u),
N			  (CPU_TS     )0,
N			  (OS_ERR    *)&err);
N}
N
N__used void bsd_unlock (void) {
X__attribute__((used)) void bsd_unlock (void) {
N  /* Release mutex - Unlock TCPnet functions. */
N  OS_ERR err;
N
N  OSMutexPost((OS_MUTEX *)&bsd_mutex,
N			  (OS_OPT     )OS_OPT_POST_1,
X			  (OS_OPT     )(OS_OPT)(0x0000u),
N			  (OS_ERR    *)&err);
N}
N#endif
N
N
N/*--------------------------- size optimization -----------------------------*/
N
N#if !(ETH_ENABLE)
X#if !(1)
S/* Empty functions when Ethernet Interface is disabled. */
SBOOL eth_chk_adr (OS_FRAME *frame)   { return (__FALSE); }
SU8  *eth_get_adr (U8 *ipadr)         { return (NULL); }
SBOOL eth_send_frame (OS_FRAME *frame){ return (__FALSE); }
N#endif
N
N#if !(ETH_ENABLE && IGMP_ENABLE)
X#if !(1 && 0)
N/* Empty functions when IP Multicasting is not enabled. */
NBOOL igmp_is_member (U8 *ipadr)      { return (__FALSE); }
XBOOL igmp_is_member (U8 *ipadr)      { return (0); }
Nvoid igmp_process (OS_FRAME *frame)  { ; }
N#endif
N
N#if (ETH_ENABLE && !DHCP_ENABLE)
X#if (1 && !0)
N/* Empty function when DHCP not enabled. */
Nvoid dhcp_disable (void)             { ; }
N#endif
N
N#if !(PPP_ENABLE)
X#if !(0)
N/* Empty function when PPP Interface is disabled. */
NBOOL ppp_send_frame (OS_FRAME *frame, U16 prot) { return (__FALSE); }
XBOOL ppp_send_frame (OS_FRAME *frame, U16 prot) { return (0); }
N#endif
N
N#if (PPP_ENABLE && !(PPP_AUTHEN && PPP_PAPEN))
X#if (0 && !(1 && 1))
S/* Empty functions when PAP authentication not enabled. */
Svoid pap_init (void)                 { ; }
Svoid pap_run (void)                  { ; }
Svoid pap_process (OS_FRAME *frame)   { ; }
N#endif
N
N#if (PPP_ENABLE && !(PPP_AUTHEN && PPP_CHAPEN))
X#if (0 && !(1 && 1))
S/* Empty functions when CHAP authentication not enabled. */
Svoid chap_init (void)                { ; }
Svoid chap_run (void)                 { ; }
Svoid chap_process (OS_FRAME *frame)  { ; }
N#endif
N
N#if !(SLIP_ENABLE)
X#if !(0)
N/* Empty function when SLIP Interface is disabled. */
NBOOL slip_send_frame (OS_FRAME *frame) { return (__FALSE); }
XBOOL slip_send_frame (OS_FRAME *frame) { return (0); }
N#endif
N
N#if !(UDP_ENABLE)
X#if !(1)
S/* Empty function when UDP socket not enabled. */
Svoid udp_process (OS_FRAME *frame)   { ; }
N#endif
N
N#if !(TCP_ENABLE)
X#if !(1)
S/* Empty function when TCP socket not enabled. */
Svoid tcp_process (OS_FRAME *frame)   { ; }
N#endif
N
N#if !(SNTP_ENABLE)
X#if !(0)
N/* Empty function when SNTP not enabled. */
NBOOL sntp_get_time (U8 *ipadr, void (*cbfunc)(U32)) { return(__FALSE); }
XBOOL sntp_get_time (U8 *ipadr, void (*cbfunc)(U32)) { return(0); }
N#endif
N
N#if (BSD_ENABLE && !__RTX)
X#if (1 && !1)
S/* Empty functions for non RTX environment. */
S__used U8   bsd_wait   (BSD_INFO *bsd_s, U8 evt) { return (0);}
S__used void bsd_enable (BSD_INFO *bsd_s, U8 evt) { ; }
N#endif
N
N#endif    /* __NET_CONFIG__ */
N
N
N/*----------------------------------------------------------------------------
N *      Library for Net_Debug.c
N *---------------------------------------------------------------------------*/
N
N#ifdef __NET_DEBUG__
S
S/* Non-Critical Net_Debug.c upgrade */
S#ifndef DBG_TIME
S #define DBG_TIME   1
S#endif
S#ifdef DBG_APP
S #define DBG_HTTP   DBG_APP
S #define DBG_FTP    DBG_APP
S #define DBG_FTPC   DBG_APP
S #define DBG_TNET   DBG_APP
S #define DBG_TFTP   DBG_APP
S #define DBG_TFTPC  DBG_APP
S #define DBG_SMTP   DBG_APP
S#endif
S
S#include <stdarg.h>
S#include <stdio.h>
S
S#pragma diag_suppress 111
S
Sextern char *dbg_time (void);
Sextern char *dbg_proc (U32 proc);
S
S/*--------------------------- __debug__ -------------------------------------*/
S
Svoid __debug__ (U32 proc, const char *fmt, ...) {
S  /* Print TCPnet Debug messages. */
S  va_list args;
S
S  switch (proc) {
S#if (DBG_MEM > 1)
S    case MODULE_MEM:  break;
S#endif
S#if (DBG_ETH > 1)
S    case MODULE_ETH:  break;
S#endif
S#if (DBG_PPP > 1)
S    case MODULE_PPP:  break;
S#endif
S#if (DBG_SLIP > 1)
S    case MODULE_SLIP: break;
S#endif
S#if (DBG_ARP > 1)
S    case MODULE_ARP:  break;
S#endif
S#if (DBG_IP > 1)
S    case MODULE_IP:   break;
S#endif
S#if (DBG_ICMP > 1)
S    case MODULE_ICMP: break;
S#endif
S#if (DBG_IGMP > 1)
S    case MODULE_IGMP: break;
S#endif
S#if (DBG_UDP > 1)
S    case MODULE_UDP:  break;
S#endif
S#if (DBG_TCP > 1)
S    case MODULE_TCP:  break;
S#endif
S#if (DBG_NBNS > 1)
S    case MODULE_NBNS: break;
S#endif
S#if (DBG_DHCP > 1)
S    case MODULE_DHCP: break;
S#endif
S#if (DBG_DNS > 1)
S    case MODULE_DNS:  break;
S#endif
S#if (DBG_SNMP > 1)
S    case MODULE_SNMP: break;
S#endif
S#if (DBG_BSD > 1)
S    case MODULE_BSD:  break;
S#endif
S#if (DBG_HTTP > 1)
S    case MODULE_HTTP: break;
S#endif
S#if (DBG_FTP > 1)
S    case MODULE_FTP:  break;
S#endif
S#if (DBG_FTPC > 1)
S    case MODULE_FTPC: break;
S#endif
S#if (DBG_TNET > 1)
S    case MODULE_TNET: break;
S#endif
S#if (DBG_TFTP > 1)
S    case MODULE_TFTP: break;
S#endif
S#if (DBG_TFTPC > 1)
S    case MODULE_TFTPC:break;
S#endif
S#if (DBG_SMTP > 1)
S    case MODULE_SMTP: break;
S#endif
S#if (DBG_SNTP > 1)
S    case MODULE_SNTP: break;
S#endif
S    default: return;
S  }
S#if (DBG_TIME)
S  printf (dbg_time());
S#endif
S  printf ("%s:",dbg_proc(proc));
S
S  va_start (args,fmt);
S  vprintf (fmt,args);
S  va_end (args);
S}
S
S
S/*--------------------------- __error__ -------------------------------------*/
S
Svoid __error__ (U32 proc, const char *fmt, ...) {
S  /* Print TCPnet Error messages. */
S  va_list args;
S
S  switch (proc) {
S#if (DBG_MEM > 0)
S    case MODULE_MEM:  break;
S#endif
S#if (DBG_ETH > 0)
S    case MODULE_ETH:  break;
S#endif
S#if (DBG_PPP > 0)
S    case MODULE_PPP:  break;
S#endif
S#if (DBG_SLIP > 0)
S    case MODULE_SLIP: break;
S#endif
S#if (DBG_ARP > 0)
S    case MODULE_ARP:  break;
S#endif
S#if (DBG_IP > 0)
S    case MODULE_IP:   break;
S#endif
S#if (DBG_ICMP > 0)
S    case MODULE_ICMP: break;
S#endif
S#if (DBG_IGMP > 0)
S    case MODULE_IGMP: break;
S#endif
S#if (DBG_UDP > 0)
S    case MODULE_UDP:  break;
S#endif
S#if (DBG_TCP > 0)
S    case MODULE_TCP:  break;
S#endif
S#if (DBG_NBNS > 0)
S    case MODULE_NBNS: break;
S#endif
S#if (DBG_DHCP > 0)
S    case MODULE_DHCP: break;
S#endif
S#if (DBG_DNS > 0)
S    case MODULE_DNS:  break;
S#endif
S#if (DBG_SNMP > 0)
S    case MODULE_SNMP: break;
S#endif
S#if (DBG_BSD > 0)
S    case MODULE_BSD:  break;
S#endif
S#if (DBG_HTTP > 0)
S    case MODULE_HTTP: break;
S#endif
S#if (DBG_FTP > 0)
S    case MODULE_FTP:  break;
S#endif
S#if (DBG_FTPC > 0)
S    case MODULE_FTPC: break;
S#endif
S#if (DBG_TNET > 0)
S    case MODULE_TNET: break;
S#endif
S#if (DBG_TFTP > 0)
S    case MODULE_TFTP: break;
S#endif
S#if (DBG_TFTPC > 0)
S    case MODULE_TFTPC:break;
S#endif
S#if (DBG_SMTP > 0)
S    case MODULE_SMTP: break;
S#endif
S#if (DBG_SNTP > 0)
S    case MODULE_SNTP: break;
S#endif
S    default: return;
S  }
S#if (DBG_TIME)
S  printf (dbg_time());
S#endif
S  printf ("%s-ERR:",dbg_proc(proc));
S
S  va_start (args,fmt);
S  vprintf (fmt,args);
S  va_end (args);
S}
S
N#endif    /* __NET_DEBUG__ */
N
N
N/*----------------------------------------------------------------------------
N * end of file
N *---------------------------------------------------------------------------*/
L 933 "..\..\RL-ARM\Config\Net_Config.c" 2
N
N/*----------------------------------------------------------------------------
N * end of file
N *---------------------------------------------------------------------------*/