news.txt

FreeRTOS 是一个源码公开的免费的嵌入式实时操作系统

NEWLY ADDED FEATURES *** CC8E
-----------------------------

NOTE: the newly added features are listed first.


>> Version 1.1F released


** Improved debugging support

  The COD file now supports data above address 0xFFFF. This
  allow larger programs, config and ID locations to be
  defined in the COD file.


** Support of CCINC and CCHOME

  Environment variables can be used to define include
  folders and primary folder:

  Variable CCINC is an alternative to the -I<path> option.
  The compiler will only read this variable (or specified
  variable) when using the following command line option:

    -li       : read default environment variable CCINC
    -li<ENVI> : read spesific environement variable

  Variable CCHOME can be used to define the primary folder
  during compilation. The compiler will only read this
  variable (or specified variable) when using the following
  command line option:

    -lh       : read default environment variable CCHOME
    -lh<ENVP> : read spesific environement variable


>> Version 1.1E released


>> Version 1.1D released


** New type modifier 'shadowDef'

  The 'shadowDef' type modifier allow local and global
  variables and function parameters to be assigned to
  specific addresses without affecting normal variable
  allocation. The compiler will ignore the presense of these
  variables when allocating global and local variable space.

    shadowDef char gx70 @ 0x70;  // global or local variable

  The above definition allow location 0x70 to be inspected and
  modified through variable 'gx70'.


** Assigning function parameters to specific locations

  Function parameters can be assigned to addresses. No other
  variables will be assigned by the compiler to these
  locations. Such manual allocation can be useful when
  reusing RAM locations manually.

    void writeByte(char addr @ 0x70, char value @ 0x71) { .. }

  This syntax is also possible on function prototypes.


** Support for mapped CONFIG data on the PIC18FxxJ1x devices

  The compiler and header files for these devices has been
  updated to allow the config data to be stored at the end
  of the FLASH program data. The config data should be
  specified as normal (see CONFIG.TXT):

    #pragma config[0] = 0b.1.000.0101


>> Version 1.1C released


** Support for __config and __idlocs

  The compiler will use __config and __idlocs in the
  generated assembly file when #pragma config is used in the
  C source. The old assembly format is still available by
  using the command line option -cfc.


** Macro's __DATE__ and __TIME__

  Macro's for date and time are defined when compilation starts.

    Macro      Format          Example
    __TIME__   HOUR:MIN:SEC    "23:59:59"
    __DATE__   MONTH DAY YEAR  "Jan  1 2005"
    __DATE2__  DAY MONTH YEAR  " 1 Jan 2005"


>> Version 1.1B released


** Custom warnings and simple messages

  A custom warning or a simple message can be printed in the
  compiler output and to the .occ file. Option -S will suppress
  this. "warning" and "message" are not reserved keywords. Note
  that these directives are not standard C.

    #message This is message 1
    #message This is message 2
    #warning This is a warning

  The following output is produced:

    Message: This is message 1
    Message: This is message 2
    Warning test.c 7: This is a warning


>> Version 1.1A released


** Functions shared between independent call trees

  An error message is normally printed when the compiler detects
  functions that are called both from main() and during interrupt
  processing if this function contains local variables or
  parameters. This also applies to math library calls and const
  access functions. The reason for the error is that local variables
  are allocated statically and may be overwritten if the routine is
  interrupted and then called during interrupt processing.

  The error message will be changed to a warning by the following
  pragma statement. Note that this means that local variable and
  parameter overwriting must be avoided by careful code writing.

    #pragma sharedAllocation


** 16 bit computed goto

   The skip inline function can use a 16 bit argument. This requires
   normally 11 instructions (14 instructions when a 64k byte
   boundary is crossed). When using relocatable assembly 14
   instructions are used on devices with more than 64k byte memory.

     uns16 s16;
     ..
     skip(s16);
     // skip to any instruction in a 65536 instruction word table
     // offset 0 is the first instruction in the table
     // offset 1 is the next instruction word in the table

     /* skipM(s16) must be used when the table contains double
        word instructions. The second word of a double word
        instruction executes a NOP if jumped to. */

     /* The following pragma is recommended if the function does
        not end immediate */
    #pragma computedGoto 0
     /* Optional C statements after the table */
    } /* end of function */


** Improved inline assembly

   The following address operations is possible when the variable/
   struct/array set to a fixed address.

     char tab[5] @ 0x110;
     struct { char x; char y; } stx @ 0x120;
    #asm
     MOVLW tab
     MOVLW &tab[1]
     MOVLW LOW &tab[2]
     MOVLW HIGH &tab[2]
     MOVLW UPPER &tab[2]
     MOVLW HIGH (&tab[2] + 2)
     MOVLW HIGH (&stx.y)
     MOVLW &stx.y
     MOVLW &STATUS
    #endasm


** Output from preprocessor

   The compiler will write the output from the preprocessor
   to a file (.CPR) when using the -B command line option.
   Preprocessor directives are either removed or simplified.
   Macro identifiers are replaced by the macro contents.

     -B[pims]  : write output from preprocessor to <src>.cpr
        p  : partial preprocessing
        i  : .., do not include files
        m  : .., modify symbols
        s  : .., modify strings

   When using the alternative preprocessing formats (-Bpims),
   compilation will stop after proprocessing.


>> Version 1.1 released


** Direct coded instructions

   The file "hexcodes.h" contains C macro's that allow direct coding
   of instructions.

   Note that direct coded instructions are different from inline
   assembly seen from the compiler. The compiler will view the
   instruction codes as values only and not as instructions. All
   high level properties are lost. The compiler will reset
   optimization, bank updating, etc. after a DW statement.

   Example usage:
     #include "hexcodes.h"
     ..
     // 1. In DW statements:
     #asm
     DW __DECF(__FSR0L,__F,0)     // Decrement FSR0L (access bank)
     DW __CLRF(0xFF,1,1)          // Clear ram (banked access)
     DW __BCF(__STATUS,__Carry,0) // Clear Carry bit
     DW __GOTO(0)                 // Goto address 0
     #endasm
     ..
     // 2. In cdata statements:
     #pragma cdata[1] = __GOTO(0x3FF)


** RAM bank update settings

   #pragma updateBank can be used to instruct the bank update
   algorithm to do certain selections. These statements can only be
   used inside a function:

     #pragma updateBank entry = 0
     /* The 'entry' bank force the bank bits to be set
        to a certain value when calling this function */

     #pragma updateBank exit = 1
     /* The 'exit' bank force the bank bits to be set 
        to a certain value at return from this function */

     #pragma updateBank default = 0
     /* The 'default' bank is used by the compiler at
        loops and labels when the algorithm give up
        finding the optimal choice */


** Origin alignment

   It is possible to use #pragma origin to ensure that a computed
   goto inside a function does not cross a 256 byte address
   boundary. However, this may require many changes during program
   development. An alternative is to use #pragma alignLsbOrigin to
   automatically align the least significant byte of the origin
   address. Note that this alignment is not possible when using
   relocatable assembly. Relocatable assembly requires another
   approach to fix the address. This is found in Section Using code
   sections on page 74 in Chapter 6.8 Linker Support.

   Example: A function contain a computed goto. After inspecting the
   generated list file, there are 15 instructions words between the
   function start and the address latch update instruction (MOVF PCL,
   W,0 updates PCLATH and PCLATU). The last computed goto
   destination address (offset 10) resides further 2 + 10
   instructions words below the address latch update instruction. A
   fast a compact computed goto requires that these addresses
   resides on the same "byte page" (i.e. (address & 0xFFFF00) are
   identical for the two addresses). This is achieved with the
   statement:

     #pragma alignLsbOrigin -(15+1)*2 to 254 - (2+10)*2 - (15+1)*2

   The alignment pragma statement is not critical. The compiler will
   generate an error (option -GS) or a warning (-GW) if the computed
   goto cross a boundary because of a wrong alignment. An easier
   approach is to align the LSB to a certain value (as long as
   program size is not critical).

     #pragma alignLsbOrigin 0            // align on LSB = 0
     #pragma alignLsbOrigin 0 to 190     // [-254 to 254]
     #pragma alignLsbOrigin -100 to 10


** Improved const data initialization

   Floating point constant expressions.

   Complex address calculations.

   Enum-symbols allowed.


>> Version 1.0I released


** Improved integer math

   New math library functions for 16*16 and 32*16 bit
   multiplication, signed and unsigned.

     math24.h: int24 operator* _multS16x16( int16 arg1, int16 arg2);
     math24.h: int8  operator% _remS24_8( int24 arg1, int8 arg2);

     math32.h: uns32 operator* _multU16x16( uns16 arg1, uns16 arg2);
     math32.h: int32 operator* _multS16x16( int16 arg1, int16 arg2);
     math32.h: uns32 operator* _multU32x16( uns32 arg1, uns16 arg2);
     math32.h: int32 operator* _multS32x16( int32 arg1, int16 arg2);
     math32.h: int8  operator% _remS32_8( int32 arg1, int8 arg2);

   Inline multiplication will now optimize for speed instead of size
   for signed integer multiplication. Optimization for size on
   inline multiplication (signed and unsigned) can be forced by
   command line option -zZ.


>> Version 1.0H released


** Switch statements of 16, 24 and 32 bit

   The switch statement now supports variables up to 32 bit. The
   generated code is more compact and executes faster than the
   equivalent 'if - else if' chain.


>> Version 1.0G released


** Macro stringification and concatenation

   The concatenation operator ## allows tokens to be merged while
   expanding macros. The stringification operator # allows a macro
   argument to be converted into a string constant.


>> Version 1.0F released


** Syntax improvements

   Multiple assignment:
     a = b = c;

   Allowing the increment operator on the left side of a statement:
     ++i;
     --x;

   Improved "increment" part of the 'for' statement :
     for (i=0; i<5; a.b[x]+=2) ..

   Better paranthesis support :
     *(p)
     (p)[0]
     &(l.a)

   Better 'enum' support :
     typedef enum ..
     enum con { Read_A, .. };
     enum con mm;
     mm = Read_A;


** Placing the interrupt routine anywhere

   The interrupt routines normally have to reside on address 0x8 and
   0x18. The following pragma statement will allow the interrupt
   routine to be placed anywhere. Note that the compiler will NOT
   generate the link from address 0x8/0x18 to the interrupt routine.

     #pragma unlockISR


** Placing 'const' data anywhere

   The compiler will normally insert 'const' data at the end of the
   user code (high address). The following pragma statement will
   allow the 'const' data to be inserted between two user functions,
   or at a specific address (if using #pragma origin first):

     #pragma insertConst


** Printing key info in the assembly file

   The compiler will print info at the end of the assembly file.
   Total code size, maximum call level, RAM usage. In addition, the
   size of each function is printed. Command line option -Au removes
   this information.


>> Version 1.0E released


** Creating and updating linker scripts automatically

   The compiler can create and update linker scripts automatically
   when using the -rsc[=<file.lkr>] command line option. More
   details are found in LINKER.TXT.


** MPLAB 6 support through a temporary solution

   The compiler can be used as a tool in MPLAB 6. It is possible to
   use MPLINK to link several object modules, or the built-in linker
   of the compiler (single module). More details are found in
   MPLAB6.TXT.


>> Version 1.0D released


>> Version 1.0C released


>> Version 1.0B released


>> Version 1.0A released


** Detailed multiline macro expansion in assembly file

   Single lines from multiline macro's are printed in the generated
   assembly file when using command line option -AR. This is
   sometimes useful to improve readability when expanding very long
   macro's.


** Recursive printing of errors in macro's

   If there is a syntax error in a defined macro, then it may be
   difficult to decide what the problem actually is. This is
   improved by printing extra error messages which points to the
   macro definition, and doing this recursively when expanding
   nested macro's.


** Automatic incrementing version number in file

   CC8E is able to automatically increment one or more version
   numbers for each compilation. Syntax supported:

   1.  Option : -ver#verfile.c
       #include "verfile.c"  // or <verfile.c>

   2.  Option : -ver
       #pragma versionFile   // next include is version file
       #include "verfile.c"  // or <verfile.c>

   3.  Option : -ver
       #pragma versionFile "verfile.c"  // or <verfile.c>

   Note that the command line option is required to make this
   increment happen. It is the decimal number found at end of
   the included file that is incremented. The updated file is
   written back before the file is compiled. No special syntax is
   assumed in the version file. Suggestions:

     #define MY_VERSION  20
     #define VER_STRING  "1.02.0005"
     /* VERSION : 01110 */

   If the decimal number is 99, then the new number will be 100 and
   the file length increases by 1. If the number is 099, then the
   file length remains the same. A version file should not be too
   large (up to 20k), otherwise an error is printed.

   Formats 2 and 3 above allows more than one version file. It is
   recommended to use conditional compilation to manage several
   editions of the same program.