libcm is a C development framework with an emphasis on audio signal processing applications.
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.

cmCsv.h 6.8KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
  1. #ifndef cmCsv_h
  2. #define cmCsv_h
  3. #ifdef __cplusplus
  4. extern "C" {
  5. #endif
  6. //( { file_desc:"Comma seperated value file reader and writer." kw[file] }
  7. enum
  8. {
  9. kOkCsvRC = 0,
  10. kMemAllocErrCsvRC,
  11. kLexErrCsvRC,
  12. kHashTblErrCsvRC,
  13. kSyntaxErrCsvRC,
  14. kFileOpenErrCsvRC,
  15. kFileCreateErrCsvRC,
  16. kFileReadErrCsvRC,
  17. kFileSeekErrCsvRC,
  18. kFileCloseErrCsvRC,
  19. kDataCvtErrCsvRC,
  20. kCellNotFoundCsvRC,
  21. kDuplicateLexCsvId
  22. };
  23. typedef unsigned cmCsvRC_t;
  24. typedef cmHandle_t cmCsvH_t;
  25. enum
  26. {
  27. kIntCsvTFl = 0x01,
  28. kHexCsvTFl = 0x02,
  29. kRealCsvTFl = 0x04,
  30. kIdentCsvTFl = 0x08,
  31. kStrCsvTFl = 0x10,
  32. kUdefCsvTFl = 0x20,
  33. kNumberTMask = kIntCsvTFl | kHexCsvTFl | kRealCsvTFl,
  34. kTextTMask = kIdentCsvTFl | kStrCsvTFl,
  35. kTypeTMask = kNumberTMask | kTextTMask
  36. };
  37. // Each non-blank CSV cell is represented by a cmCsvCell_t record.
  38. // All the non-blank cells in a given row are organized as a linked
  39. // list throught 'rowPtr'.
  40. typedef struct cmCsvCell_str
  41. {
  42. unsigned row; // CSV row number
  43. unsigned col; // CSV column number
  44. struct cmCsvCell_str* rowPtr; // links together cells in this row
  45. unsigned symId; // symbol id for this cell
  46. unsigned flags; // cell flags (see kXXXCsvTFl)
  47. unsigned lexTId;
  48. } cmCsvCell_t;
  49. extern cmCsvH_t cmCsvNullHandle;
  50. cmCsvRC_t cmCsvInitialize( cmCsvH_t *hp, cmCtx_t* ctx );
  51. cmCsvRC_t cmCsvFinalize( cmCsvH_t *hp );
  52. cmCsvRC_t cmCsvInitializeFromFile( cmCsvH_t *hp, const char* fn, unsigned maxRowCnt, cmCtx_t* ctx );
  53. bool cmCsvIsValid( cmCsvH_t h);
  54. cmCsvRC_t cmCsvLastRC( cmCsvH_t h);
  55. void cmCsvClearRC( cmCsvH_t h);
  56. // Register token matchers. See cmLexRegisterToken and cmLexRegisterMatcher
  57. // for details.
  58. cmCsvRC_t cmCsvLexRegisterToken( cmCsvH_t h, unsigned id, const cmChar_t* token );
  59. cmCsvRC_t cmCsvLexRegisterMatcher( cmCsvH_t h, unsigned id, cmLexUserMatcherPtr_t funcPtr );
  60. // Return the next available lexer token id above the token id's used internally
  61. // by the object. This value is fixed after cmCsvInitialize()
  62. // and does not change for the life of the CSV object. The application is
  63. // therefore free to choose any lexer id values equal to or above the
  64. // returned value.
  65. unsigned cmCsvLexNextAvailId( cmCsvH_t h );
  66. // Set 'maxRowCnt' to 0 if there is no row limit on the file.
  67. cmCsvRC_t cmCsvParse( cmCsvH_t h, const char* buf, unsigned bufCharCnt, unsigned maxRowCnt );
  68. cmCsvRC_t cmCsvParseFile( cmCsvH_t h, const char* fn, unsigned maxRowCnt );
  69. unsigned cmCsvRowCount( cmCsvH_t h );
  70. // Return a pointer to a given cell.
  71. cmCsvCell_t* cmCsvCellPtr( cmCsvH_t h, unsigned row, unsigned col );
  72. // Return a pointer to the first cell in a given row
  73. cmCsvCell_t* cmCsvRowPtr( cmCsvH_t h, unsigned row );
  74. // Convert a cell symbold id to a value.
  75. const char* cmCsvCellSymText( cmCsvH_t h, unsigned symId );
  76. cmCsvRC_t cmCsvCellSymInt( cmCsvH_t h, unsigned symId, int* vp );
  77. cmCsvRC_t cmCsvCellSymUInt( cmCsvH_t h, unsigned symId, unsigned* vp );
  78. cmCsvRC_t cmCsvCellSymFloat( cmCsvH_t h, unsigned symId, float* vp );
  79. cmCsvRC_t cmCsvCellSymDouble( cmCsvH_t h, unsigned symId, double* vp );
  80. // Return the value associated with a cell.
  81. const char* cmCsvCellText( cmCsvH_t h, unsigned row, unsigned col ); // Returns NULL on error.
  82. int cmCsvCellInt( cmCsvH_t h, unsigned row, unsigned col ); // Returns INT_MAX on error.
  83. unsigned cmCsvCellUInt( cmCsvH_t h, unsigned row, unsigned col ); // Returns UINT_MAX on error.
  84. float cmCsvCellFloat( cmCsvH_t h, unsigned row, unsigned col ); // Returns FLT_MAX on error.
  85. double cmCsvCellDouble(cmCsvH_t h, unsigned row, unsigned col ); // Returns DBL_MAX on error.
  86. // Insert a value into the internal symbol table.
  87. unsigned cmCsvInsertSymText( cmCsvH_t h, const char* text );
  88. unsigned cmCsvInsertSymInt( cmCsvH_t h, int v );
  89. unsigned cmCsvInsertSymUInt( cmCsvH_t h, unsigned v );
  90. unsigned cmCsvInsertSymHex( cmCsvH_t h, unsigned v );
  91. unsigned cmCsvInsertSymFloat( cmCsvH_t h, float v );
  92. unsigned cmCsvInsertSymDouble( cmCsvH_t h, double v );
  93. // Set the value associated with a cell.
  94. cmCsvRC_t cmCsvSetCellText( cmCsvH_t h, unsigned row, unsigned col, const char* text );
  95. cmCsvRC_t cmCsvSetCellInt( cmCsvH_t h, unsigned row, unsigned col, int v );
  96. cmCsvRC_t cmCsvSetCellUInt( cmCsvH_t h, unsigned row, unsigned col, unsigned v );
  97. cmCsvRC_t cmCsvSetCellHex( cmCsvH_t h, unsigned row, unsigned col, unsigned v );
  98. cmCsvRC_t cmCsvSetCellFloat( cmCsvH_t h, unsigned row, unsigned col, float v );
  99. cmCsvRC_t cmCsvSetCellDouble( cmCsvH_t h, unsigned row, unsigned col, double v );
  100. // Insert a new row and column 0 cell just above the row assigned to 'row'.
  101. // lexTId is an arbitrary id used by the application to set the value of
  102. // cmCsvCell_t.lexTId in the new cell. There are no constraints on its value.
  103. //cmCsvRC_t cmCsvInsertRowBefore( cmCsvH_t h, unsigned row, cmCsvCell_t** cellPtrPtr, unsigned symId, unsigned flags, unsigned lexTId );
  104. // Column 0 will be added if 'cellPtrPtr'!= NULL and 'symId'!=cmInvalidId.
  105. // If cellPtrPtr and symId are not valid then 'flags' and 'lexTId' are ignored.
  106. cmCsvRC_t cmCsvAppendRow( cmCsvH_t h, cmCsvCell_t** cellPtrPtr, unsigned symId, unsigned flags, unsigned lexTId );
  107. // Insert a new cell to the right of leftCellPtr.
  108. // lexTId is an arbitrary id used by the application to set the value of
  109. // cmCsvCell_t.lexTId in the new cell. There are no constraints on its value.
  110. cmCsvRC_t cmCsvInsertColAfter( cmCsvH_t h, cmCsvCell_t* leftCellPtr, cmCsvCell_t** cellPtrPtr, unsigned symId, unsigned flags, unsigned lexTId );
  111. cmCsvRC_t cmCsvInsertTextColAfter( cmCsvH_t h, cmCsvCell_t* leftCellPtr, cmCsvCell_t** cellPtrPtr, const char* val, unsigned lexTId );
  112. cmCsvRC_t cmCsvInsertIntColAfter( cmCsvH_t h, cmCsvCell_t* leftCellPtr, cmCsvCell_t** cellPtrPtr, int val, unsigned lexTId );
  113. cmCsvRC_t cmCsvInsertUIntColAfter( cmCsvH_t h, cmCsvCell_t* leftCellPtr, cmCsvCell_t** cellPtrPtr, unsigned val, unsigned lexTId );
  114. cmCsvRC_t cmCsvInsertHexColAfter( cmCsvH_t h, cmCsvCell_t* leftCellPtr, cmCsvCell_t** cellPtrPtr, unsigned val, unsigned lexTId );
  115. cmCsvRC_t cmCsvInsertFloatColAfter( cmCsvH_t h, cmCsvCell_t* leftCellPtr, cmCsvCell_t** cellPtrPtr, float val, unsigned lexTId );
  116. cmCsvRC_t cmCsvInsertDoubleColAfter( cmCsvH_t h, cmCsvCell_t* leftCellPtr, cmCsvCell_t** cellPtrPtr, double val, unsigned lexTId );
  117. // Write the CSV object out to a file.
  118. cmCsvRC_t cmCsvWrite( cmCsvH_t h, const char* fn );
  119. cmCsvRC_t cmCsvPrint( cmCsvH_t h, unsigned rowCnt );
  120. //)
  121. #ifdef __cplusplus
  122. }
  123. #endif
  124. #endif