libcm is a C development framework with an emphasis on audio signal processing applications.
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

cmLex.h 6.6KB

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