libcm is a C development framework with an emphasis on audio signal processing applications.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
  1. #ifndef cmLex_h
  2. #define cmLex_h
  3. //( { file_desc:"User configurable lexer for tokenizing text files." kw:[text]}
  4. // Predefined Lexer Id's
  5. enum
  6. {
  7. kErrorLexTId, // 0 the lexer was unable to identify the current token
  8. kUnknownLexTId, // 1 the token is of an unknown type (only used when kReturnUnknownLexFl is set)
  9. kEofLexTId, // 2 the lexer reached the end of input
  10. kSpaceLexTId, // 3 white space
  11. kRealLexTId, // 4 real number (contains a decimal point or is in scientific notation)
  12. kIntLexTId, // 5 decimal integer
  13. kHexLexTId, // 6 hexidecimal integer
  14. kIdentLexTId, // 7 identifier
  15. kQStrLexTId, // 8 quoted string
  16. kQCharLexTId, // 9 quoted char
  17. kBlockCmtLexTId, // 10 block comment
  18. kLineCmtLexTId, // 11 line comment
  19. kUserLexTId // 12 user registered token (See cmLexRegisterToken().)
  20. };
  21. // Lexer control flags used with cmLexInit().
  22. enum
  23. {
  24. kReturnSpaceLexFl = 0x01, //< Return space tokens
  25. kReturnCommentsLexFl = 0x02, //< Return comment tokens
  26. kReturnUnknownLexFl = 0x04, //< Return unknown tokens
  27. kReturnQCharLexFl = 0x08, //< Return quoted characters
  28. kUserDefPriorityLexFl= 0x10 //< User defined tokens take priority even if a kIdentLexTId token has a longer match
  29. };
  30. // cmLex result codes.
  31. enum
  32. {
  33. kOkLexRC = cmOkRC, //< 0 No error. The operation completed successfully
  34. kDuplicateTokenLexRC, //< 1 The text or id passed as a user token is already in use by another token
  35. kMissingCmtEndLexRC, //< 2 The end of a block comment could not be found.
  36. kMissingEndQuoteLexRC, //< 3 The end of a quoted string could not be found.
  37. kNoMatchLexRC, //< 4 The lexer encountered a string which could not be classified.
  38. kFileOpenErrLexRC, //< 5 File open failed on cmLexSetFile()
  39. kFileSeekErrLexRC, //< 6 File seek failed on cmLexSetFile()
  40. kFileTellErrLexRC, //< 7 File tell failed on cmLexSetFile()
  41. kFileReadErrLexRC, //< 8 File read failed on cmLexSetFile()
  42. kFileCloseErrLexRC, //< 9 File close failed on cmLexSetFile()
  43. kMemAllocErrLexRC, //< 10 An attempted memory allocation failed
  44. kEofRC, //< 11 The end of the input text was encountered (this is a normal condition not an error)
  45. kInvalidLexTIdLexRC, //< 12 An invalid lex token id was encountered.
  46. kSignErrorLexRC, //< 13 An signed integer has a 'u' or 'U' suffix."
  47. kInvalidLexRC //< 1r Sentinal value.
  48. };
  49. typedef cmHandle_t cmLexH;
  50. extern cmLexH cmLexNullH;
  51. // Iniitalize the lexer and receive a lexer handle in return.
  52. // Set cp to NULL if the buffer will be later via cmLexSetTextBuffer();
  53. // See the kXXXLexFl enum's above for possible flag values.
  54. cmLexH cmLexInit( const cmChar_t* cp, unsigned cn, unsigned flags, cmRpt_t* rpt );
  55. // Finalize a lexer created by an earlier call to cmLexInit()
  56. cmRC_t cmLexFinal( cmLexH* hp );
  57. // Rewind the lexer to the begining of the buffer (the same as post initialize state)
  58. cmRC_t cmLexReset( cmLexH h );
  59. // Verify that a lexer handle is valid
  60. bool cmLexIsValid( cmLexH h );
  61. // Set a new text buffer and reset the lexer to the post initialize state.
  62. cmRC_t cmLexSetTextBuffer( cmLexH h, const cmChar_t* cp, unsigned cn );
  63. cmRC_t cmLexSetFile( cmLexH h, const cmChar_t* fn );
  64. // Register a user defined token. The id of the first user defined token should be
  65. // kUserLexTId+1. Neither the id or token text can be used by a previously registered
  66. // or built-in token.
  67. cmRC_t cmLexRegisterToken( cmLexH h, unsigned id, const cmChar_t* token );
  68. // Register a user defined token recognition function. This function should return the count
  69. // of initial, consecutive, characters in 'cp[cn]' which match its token pattern.
  70. typedef unsigned (*cmLexUserMatcherPtr_t)( const cmChar_t* cp, unsigned cn );
  71. cmRC_t cmLexRegisterMatcher( cmLexH h, unsigned id, cmLexUserMatcherPtr_t funcPtr );
  72. // Enable or disable the specified token type.
  73. cmRC_t cmLexEnableToken( cmLexH h, unsigned id, bool enableFl );
  74. // Get and set the lexer filter flags kReturnXXXLexFl.
  75. // These flags can be safely enabled and disabled between
  76. // calls to cmLexGetNextToken().
  77. unsigned cmLexFilterFlags( cmLexH h );
  78. void cmLexSetFilterFlags( cmLexH h, unsigned flags );
  79. // Return the type id of the current token and advances to the next token
  80. unsigned cmLexGetNextToken( cmLexH h );
  81. // Return the type id associated with the current token. This is the same value
  82. // returned by the previous call to cmLexGetNextToken().
  83. unsigned cmLexTokenId( cmLexH h );
  84. // Return a pointer to the first character of text associated with the
  85. // current token. The returned pointer directly references the text contained
  86. // in the buffer given to the lexer in the call to cmLexInit(). The string
  87. // is therefore not zero terminated. Use cmLexTokenCharCount() to get the
  88. // length of the token string.
  89. const cmChar_t* cmLexTokenText( cmLexH h );
  90. // Return the count of characters in the text associated with the current token.
  91. // This is the only way to get this count since the string returned by
  92. // cmLexTokenText() is not zero terminated.
  93. unsigned cmLexTokenCharCount( cmLexH h );
  94. // Return the value of the current token as an integer.
  95. int cmLexTokenInt( cmLexH h );
  96. // Return the value of the current token as an unsigned integer.
  97. unsigned cmLexTokenUInt( cmLexH h );
  98. // Return the value of the current token as a float.
  99. float cmLexTokenFloat( cmLexH h );
  100. // Return the value of the current token as a double.
  101. double cmLexTokenDouble( cmLexH h );
  102. // Return true if the current token is an int and it was suffixed
  103. // with 'u' to indicate that it is unsigned.
  104. bool cmLexTokenIsUnsigned( cmLexH h );
  105. // Return true if the current token is a real and it was suffexed
  106. // with 'f' to indicate that it is a single precision float.
  107. bool cmLexTokenIsSinglePrecision( cmLexH h );
  108. // Return the line number associated with the current token
  109. unsigned cmLexCurrentLineNumber( cmLexH h );
  110. // Return the starting column of the current token
  111. unsigned cmLexCurrentColumnNumber( cmLexH h );
  112. // Return the RC code associated with the last error
  113. unsigned cmLexErrorRC( cmLexH h );
  114. // Return the label associated with a token id
  115. const cmChar_t* cmLexIdToLabel( cmLexH h, unsigned typeId );
  116. // Return the text message associated with a return code.
  117. const cmChar_t* cmLexRcToMsg( unsigned rc );
  118. // Lexer testing stub.
  119. void cmLexTest( cmRpt_t* rpt );
  120. //)
  121. #endif