libcm is a C development framework with an emphasis on audio signal processing applications.
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.

cmLex.h 6.5KB

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