camp2ascii

camp2ascii Svn Source Tree

Root/trunk

File Age Rev Message Size
  ..
tree doc 8 years 3 months 5 bavay: Created an svg version of the file structure
blob camp2ascii.c 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 2.31 kB
blob camp2ascii.h 9 years 10 months 2 bavay: Initial version using SVN (version number updated to 0.99.6). FP4 fields datatypes support still need to be finished while support for "UINT4", "INT2" and "BOOL2" needs to be checked. 757 bytes
blob camp2ascii.lsm 9 years 10 months 2 bavay: Initial version using SVN (version number updated to 0.99.6). FP4 fields datatypes support still need to be finished while support for "UINT4", "INT2" and "BOOL2" needs to be checked. 462 bytes
blob files.c 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 14.78 kB
blob files.h 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 1.35 kB
blob frame_read.c 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 7.86 kB
blob frame_read.h 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 1.29 kB
blob generic_functions.c 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 4.50 kB
blob generic_functions.h 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 1.16 kB
blob initializations.c 8 years 3 months 6 bavay: fixed some issues with recent GCC (however, the warning "format not a string literal and no format arguments" might not get fixed any time soon... extra verifications are great, but since C does not offer any alternative for dynamic formatting, we're stuck there) 11.02 kB
blob initializations.h 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 1.04 kB
blob limits.h 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 1.80 kB
blob Makefile 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 2.36 kB
blob structures.h 8 years 3 months 6 bavay: fixed some issues with recent GCC (however, the warning "format not a string literal and no format arguments" might not get fixed any time soon... extra verifications are great, but since C does not offer any alternative for dynamic formatting, we're stuck there) 6.10 kB
blob types_processing.c 8 years 3 months 6 bavay: fixed some issues with recent GCC (however, the warning "format not a string literal and no format arguments" might not get fixed any time soon... extra verifications are great, but since C does not offer any alternative for dynamic formatting, we're stuck there) 13.12 kB
blob types_processing.h 9 years 10 months 1 bavay: This is the changelog for releases predating svn repository v0.99.5: *portability improvements: all sections of the code that might see an effect from platform/compiler word lenght should have been protected by using the C99 types (such as "int32", "uint8", etc) *some cleanup in the handling of the printing of fields' values (the separator is not printed by the Read_XXX functions anymore). It also makes the formats strings easier to read. *cleanup of the code for TOB1 support *a few small speed optimizations v0.99: *almost complete support for TOB1 format (only a separator at the begining of each lines that needs removal) *much more data types supported and checked: now LONG, ULONG, SHORT, USHORT, SecNano and BOOL have been added to the list of data types that are proven to work *The only data types that still need to be validated are: BOOL2, UINT4, INT2 and FP4 *complete support of ASCII type, including when generated on a buggy data logger (some data loggers released before 2005 where issuing strings as a succession of one character string, of data type "ASCII" instead of being "ASCII(1)" *some code cleanup (dead members of the structures) v0.97: *data types handled using simple function calls because the fonction pointers were way too slow. *the very low level data reading function are now in the same file as the data types reading functions, in order to allow for inlining *some code clean up v0.95: *data types are now handled using a table of function pointers. Reading a data line is now just a matter of looping over a table and calling the contained functions. *some reorganization on the way the functions are called in order to cope with the major change previously mentionned v0.9: *added support for padding in data lines *added more data types: BOOL4, INT4, NSec v0.85: *initial release 3.18 kB

svn co -r HEAD https://models.slf.ch/svn/camp2ascii/trunk Help

Revision: HEAD

Branches:
trunk