• Top
  • Documentation
  • Books
  • Boolean-reasoning
  • Projects
  • Debugging
  • Community
  • Std
  • Proof-automation
  • Macro-libraries
  • ACL2
  • Interfacing-tools
  • Hardware-verification
  • Software-verification
    • Kestrel-books
      • Crypto-hdwallet
      • Apt
      • Error-checking
      • Fty-extensions
      • Isar
      • Kestrel-utilities
      • Set
      • C
        • Syntax-for-tools
          • Formalized-subset
          • Mapping-to-language-definition
          • Input-files
          • Compilation-database
          • Printer
          • Output-files
          • Abstract-syntax-operations
          • Implementation-environments
          • Abstract-syntax
          • Concrete-syntax
          • Disambiguation
          • Validation
          • Gcc-builtins
          • Preprocessing
          • Parsing
            • Parser
              • Parse-exprs/decls/stmts
              • Parser-states
              • Parse-external-declaration
              • Parse-cast-expression
              • Parse-expression-or-type-name
              • Parse-postfix-expression
              • Lexer
                • Check-full-ppnumber
                • Lex-lexeme
                • Lex-oct-iconst-/-dec-fconst
                • Lex-?-integer-suffix
                • Lex-hex-iconst/fconst
                • Lex-identifier/keyword
                • Lex-dec-iconst/fconst
                • Lex-block-comment
                • Lex-escape-sequence
                • Read-token
                • Lex-*-hexadecimal-digit
                • Lex-?-floating-suffix
                • Lex-*-c-char
                • Lex-*-s-char
                • Lex-prepr-directive
                • Lex-line-comment
                • Lex-*-digit
                • Lex-*-q-char
                • Lex-*-h-char
                • Lex-iconst/fconst
                • Lex-?-exponent-part
                • Lex-character-constant
                • Lexeme
                • Lex-string-literal
                • Lex-dec-fconst
                • Reread-to-token
                • Lex-non-octal-digit
                • Lex-hexadecimal-digit
                • Lex-header-name
                • Lex-binary-exponent-part
                • Lex-exponent-part
                • Lex-?-sign
                • Only-whitespace-backward-through-line
                • Lexeme-option
                • Lex-hex-quad
                • Unread-to-token
                • Read-stringlit
                • Unread-tokens
                • Read-identifier
                • Read-punctuator
                • Read-keyword
                • Unread-token
                • Irr-lexeme
              • Parse-primary-expression
              • Token-unary-expression-start-p
              • Parse-declaration-specifier
              • Parse-declaration-specifiers
              • Parse-unary-expression-or-parenthesized-type-name
              • Parse-asm-name-specifier
              • Parse-specifier/qualifier
              • Parse-expression-rest
              • Token-type-specifier-keyword-p
              • Parse-fileset
              • Parse-*-external-declaration
              • Parse-declarator-or-abstract-declarator
              • Parse-asm-goto-labels
              • Parse-asm-clobbers
              • Parse-translation-unit
              • Parse-*-label-declaration
              • Token-postfix-expression-rest-start-p
              • Parse-?-asm-name-specifier
              • Parse-*-comma-identifier
              • Parse-postfix-expression-rest
              • Parse-expression
              • Make-expr-unary-with-preinc/predec-ops
              • Parse-*-stringlit
              • Parse-statement
              • Token-struct-declaration-start-p
              • Parse-*-attribute-specifier
              • Parse-initializer-list
              • Parse-file
              • Parse-pointer
              • Parse-label-declaration
              • Parse-array/function-declarator
              • Token-type-qualifier-p
              • Parse-*-asm-qualifier
              • Parse-parameter-declaration
              • Parse-attribute-name
              • Parse-argument-expressions
              • Make-expr-cast/add-or-cast/sub-ambig
              • Parse-struct-or-union-specifier
              • Parse-declaration-or-statement
              • Parse-assignment-expression
              • Parse-asm-clobber
              • Token-specifier/qualifier-start-p
              • Token-primary-expression-start-p
              • Token-function-specifier-p
              • Token-expression-start-p
              • Parse-*-increment/decrement
              • Parse-direct-abstract-declarator
              • Parse-compound-statement
              • Token-to-type-specifier-keyword
              • Parse-unary-expression
              • Parse-argument-expressions-rest
              • Parse-generic-associations-rest
              • Parse-conditional-expression
              • Parse-fileset-loop
              • Parse-direct-abstract-declarator-rest
              • Token-designation?-initializer-start-p
              • Token-declaration-specifier-start-p
              • Parse-designator-list
              • Token-abstract-declarator-start-p
              • Parse-?-asm-output-operands
              • Parse-?-asm-input-operands
              • Parse-struct-declaration
              • Parse-specifier-qualifier-list
              • Parse-parameter-declaration-list
              • Parse-constant-expression
              • Token-type-specifier-start-p
              • Token-type-qualifier-or-attribute-specifier-start-p
              • Parse-static-assert-declaration
              • Parse-direct-declarator
              • Parse-declaration
              • Parse-attribute-parameters
              • Token-unary-operator-p
              • Token-to-unary-operator
              • Token-to-type-qualifier
              • Token-storage-class-specifier-p
              • Token-initializer-start-p
              • Token-direct-abstract-declarator-start-p
              • Token-declarator-start-p
              • Parse-initializer
              • Parse-direct-declarator-rest
              • Token-to-storage-class-specifier
              • Token-to-assignment-operator
              • Token-to-asm-qualifier
              • Token-struct-declarator-start-p
              • Token-direct-declarator-start-p
              • Token-assignment-operator-p
              • Parse-type-qualifier-and-attribute-specifier-list
              • Parse-enumerator-list
              • Parse-designation?-initializer
              • Parse-compound-literal
              • Parse-block-item
              • Token-type-name-start-p
              • Token-to-function-specifier
              • Token-preinc/predec-operator-p
              • Token-multiplicative-operator-p
              • Token-designator-start-p
              • Token-designation-start-p
              • Parse-generic-association
              • Parse-declaration-list
              • Parse-attribute-specifier
              • Parse-asm-output-operands
              • Token-to-relational-operator
              • Token-to-preinc/predec-operator
              • Token-to-multiplicative-operator
              • Token-relational-operator-p
              • Token-equality-operator-p
              • Token-asm-qualifier-p
              • Token-additive-operator-p
              • Parse-asm-statement
              • Parse-asm-input-operands
              • Token-to-equality-operator
              • Token-to-additive-operator
              • Token-shift-operator-p
              • Parser-messages
              • Parse-type-name
              • Parse-struct-declarator-list
              • Parse-struct-declaration-list
              • Parse-relational-expression-rest
              • Parse-multiplicative-expression-rest
              • Parse-logical-or-expression-rest
              • Parse-logical-and-expression-rest
              • Parse-inclusive-or-expression-rest
              • Parse-exclusive-or-expression-rest
              • Parse-equality-expression-rest
              • Parse-array/function-abstract-declarator
              • Parse-additive-expression-rest
              • Token-to-shift-operator
              • Parse-struct-declarator
              • Parse-shift-expression-rest
              • Parse-member-designor
              • Parse-init-declarator-list
              • Parse-init-declarator
              • Parse-designator
              • Parse-and-expression-rest
              • Parse-alignment-specifier
              • Reader
              • Parse-shift-expression
              • Parse-relational-expression
              • Parse-multiplicative-expression
              • Parse-logical-or-expression
              • Parse-logical-and-expression
              • Parse-inclusive-or-expression
              • Parse-exclusive-or-expression
              • Parse-equality-expression
              • Parse-enum-specifier
              • Parse-block-item-list
              • Parse-attribute-list
              • Parse-and-expression
              • Parse-additive-expression
              • Parse-abstract-declarator
              • Parse-member-designor-rest
              • Parse-declarator
              • Parse-attribute
              • Parse-type-qualifier-or-attribute-specifier
              • Parse-enumerator
              • Parse-asm-output-operand
              • Parse-asm-input-operand
        • Atc
        • Transformation-tools
        • Language
        • Representation
        • Insertion-sort
        • Pack
      • Soft
      • Bv
      • Imp-language
      • Ethereum
      • Event-macros
      • Java
      • Riscv
      • Bitcoin
      • Zcash
      • Yul
      • ACL2-programming-language
      • Prime-fields
      • Json
      • Syntheto
      • File-io-light
      • Cryptography
      • Number-theory
      • Axe
      • Lists-light
      • Builtins
      • Solidity
      • Helpers
      • Htclient
      • Typed-lists-light
      • Arithmetic-light
    • X86isa
    • Axe
    • Execloader
  • Math
  • Testing-utilities

• Lexer

Lex-?-integer-suffix

Lex an integer suffix, if present.

Signature

(lex-?-integer-suffix parstate) 
  → 
(mv erp isuffix? last/next-pos new-parstate)

Arguments

parstate — Guard (parstatep parstate).

Returns

isuffix? — Type (isuffix-optionp isuffix?).

last/next-pos — Type (positionp last/next-pos).

new-parstate — Type (parstatep new-parstate), given (parstatep parstate).

If a suffix is found, the last/next-pos output is the position of its last character. Otherwise, it is the first position where the suffix would start.

We read the next character. If there is no next character, there is no integer suffix.

If the next character is l or L, there must be an integer suffix starting with a length indication. We try to read a second l or L if any, to decide on whether the length indication is for long or long long. After that, we read more to see if there is u or U, which provides a sign indication if present. Based on all the cases, we create the appropriate integer suffix. We unread any characters that are not part of the suffix, since they may form the next lexeme (whether that will pass parsing is a separate issue: here we follow the lexical rules for longest lexeme).

If the next character is u or U, there must be an integer suffix starting with a sign indication. We attempt to read an additional length indication, in a manner similar to the previous case, and we return the appropriate integer suffix at the end, unreading any characters that may be part of the next lexeme.

This code turned out to be verbose. We could shorten it by merging the treatment of lowercase l and uppercase L, single or double.

Definitions and Theorems

Function: lex-?-integer-suffix

(defun lex-?-integer-suffix (parstate)
 (declare (xargs :stobjs (parstate)))
 (declare (xargs :guard (parstatep parstate)))
 (let ((__function__ 'lex-?-integer-suffix))
  (declare (ignorable __function__))
  (b* (((reterr) nil (irr-position) parstate)
       ((erp char pos parstate)
        (read-char parstate)))
   (cond
    ((not char) (retok nil pos parstate))
    ((utf8-= char (char-code #\l))
     (b* (((erp char2 pos2 parstate)
           (read-char parstate)))
      (cond
       ((not char2)
        (retok (isuffix-l (lsuffix-locase-l))
               pos parstate))
       ((utf8-= char2 (char-code #\l))
        (b* (((erp char3 pos3 parstate)
              (read-char parstate)))
         (cond
              ((not char3)
               (retok (isuffix-l (lsuffix-locase-ll))
                      pos2 parstate))
              ((utf8-= char3 (char-code #\u))
               (retok (make-isuffix-lu :length (lsuffix-locase-ll)
                                       :unsigned (usuffix-locase-u))
                      pos3 parstate))
              ((utf8-= char3 (char-code #\U))
               (retok (make-isuffix-lu :length (lsuffix-locase-ll)
                                       :unsigned (usuffix-upcase-u))
                      pos3 parstate))
              (t (b* ((parstate (unread-char parstate)))
                   (retok (isuffix-l (lsuffix-locase-ll))
                          pos2 parstate))))))
       ((utf8-= char2 (char-code #\u))
        (retok (make-isuffix-lu :length (lsuffix-locase-l)
                                :unsigned (usuffix-locase-u))
               pos2 parstate))
       ((utf8-= char2 (char-code #\U))
        (retok (make-isuffix-lu :length (lsuffix-locase-l)
                                :unsigned (usuffix-upcase-u))
               pos2 parstate))
       (t (b* ((parstate (unread-char parstate)))
            (retok (isuffix-l (lsuffix-locase-l))
                   pos parstate))))))
    ((utf8-= char (char-code #\L))
     (b* (((erp char2 pos2 parstate)
           (read-char parstate)))
      (cond
       ((not char2)
        (retok (isuffix-l (lsuffix-upcase-l))
               pos parstate))
       ((utf8-= char2 (char-code #\L))
        (b* (((erp char3 pos3 parstate)
              (read-char parstate)))
         (cond
              ((not char3)
               (retok (isuffix-l (lsuffix-upcase-ll))
                      pos2 parstate))
              ((utf8-= char3 (char-code #\u))
               (retok (make-isuffix-lu :length (lsuffix-upcase-ll)
                                       :unsigned (usuffix-locase-u))
                      pos3 parstate))
              ((utf8-= char3 (char-code #\U))
               (retok (make-isuffix-lu :length (lsuffix-upcase-ll)
                                       :unsigned (usuffix-upcase-u))
                      pos3 parstate))
              (t (b* ((parstate (unread-char parstate)))
                   (retok (isuffix-l (lsuffix-upcase-ll))
                          pos2 parstate))))))
       ((utf8-= char2 (char-code #\u))
        (retok (make-isuffix-lu :length (lsuffix-upcase-l)
                                :unsigned (usuffix-locase-u))
               pos2 parstate))
       ((utf8-= char2 (char-code #\U))
        (retok (make-isuffix-lu :length (lsuffix-upcase-l)
                                :unsigned (usuffix-upcase-u))
               pos2 parstate))
       (t (b* ((parstate (unread-char parstate)))
            (retok (isuffix-l (lsuffix-upcase-l))
                   pos parstate))))))
    ((utf8-= char (char-code #\u))
     (b* (((erp char2 pos2 parstate)
           (read-char parstate)))
      (cond
       ((not char2)
        (retok (isuffix-u (usuffix-locase-u))
               pos parstate))
       ((utf8-= char2 (char-code #\l))
        (b* (((erp char3 pos3 parstate)
              (read-char parstate)))
         (cond
           ((not char3)
            (retok (make-isuffix-ul :unsigned (usuffix-locase-u)
                                    :length (lsuffix-locase-l))
                   pos2 parstate))
           ((utf8-= char3 (char-code #\l))
            (retok (make-isuffix-ul :unsigned (usuffix-locase-u)
                                    :length (lsuffix-locase-ll))
                   pos3 parstate))
           (t (b* ((parstate (unread-char parstate)))
                (retok (make-isuffix-ul :unsigned (usuffix-locase-u)
                                        :length (lsuffix-locase-l))
                       pos2 parstate))))))
       ((utf8-= char2 (char-code #\L))
        (b* (((erp char3 pos3 parstate)
              (read-char parstate)))
         (cond
           ((not char3)
            (retok (make-isuffix-ul :unsigned (usuffix-locase-u)
                                    :length (lsuffix-upcase-l))
                   pos2 parstate))
           ((utf8-= char3 (char-code #\L))
            (retok (make-isuffix-ul :unsigned (usuffix-locase-u)
                                    :length (lsuffix-upcase-ll))
                   pos3 parstate))
           (t (b* ((parstate (unread-char parstate)))
                (retok (make-isuffix-ul :unsigned (usuffix-locase-u)
                                        :length (lsuffix-upcase-l))
                       pos2 parstate))))))
       (t (b* ((parstate (unread-char parstate)))
            (retok (isuffix-u (usuffix-locase-u))
                   pos parstate))))))
    ((utf8-= char (char-code #\U))
     (b* (((erp char2 pos2 parstate)
           (read-char parstate)))
      (cond
       ((not char2)
        (retok (isuffix-u (usuffix-upcase-u))
               pos parstate))
       ((utf8-= char2 (char-code #\l))
        (b* (((erp char3 pos3 parstate)
              (read-char parstate)))
         (cond
           ((not char3)
            (retok (make-isuffix-ul :unsigned (usuffix-upcase-u)
                                    :length (lsuffix-locase-l))
                   pos2 parstate))
           ((utf8-= char3 (char-code #\l))
            (retok (make-isuffix-ul :unsigned (usuffix-upcase-u)
                                    :length (lsuffix-locase-ll))
                   pos3 parstate))
           (t (b* ((parstate (unread-char parstate)))
                (retok (make-isuffix-ul :unsigned (usuffix-upcase-u)
                                        :length (lsuffix-locase-l))
                       pos2 parstate))))))
       ((utf8-= char2 (char-code #\L))
        (b* (((erp char3 pos3 parstate)
              (read-char parstate)))
         (cond
           ((not char3)
            (retok (make-isuffix-ul :unsigned (usuffix-upcase-u)
                                    :length (lsuffix-upcase-l))
                   pos2 parstate))
           ((utf8-= char3 (char-code #\L))
            (retok (make-isuffix-ul :unsigned (usuffix-upcase-u)
                                    :length (lsuffix-upcase-ll))
                   pos3 parstate))
           (t (b* ((parstate (unread-char parstate)))
                (retok (make-isuffix-ul :unsigned (usuffix-upcase-u)
                                        :length (lsuffix-upcase-l))
                       pos2 parstate))))))
       (t (b* ((parstate (unread-char parstate)))
            (retok (isuffix-u (usuffix-upcase-u))
                   pos parstate))))))
    (t (b* ((parstate (unread-char parstate)))
         (retok nil pos parstate)))))))

Theorem: isuffix-optionp-of-lex-?-integer-suffix.isuffix?

(defthm isuffix-optionp-of-lex-?-integer-suffix.isuffix?
  (b* (((mv acl2::?erp
            ?isuffix? ?last/next-pos ?new-parstate)
        (lex-?-integer-suffix parstate)))
    (isuffix-optionp isuffix?))
  :rule-classes :rewrite)

Theorem: positionp-of-lex-?-integer-suffix.last/next-pos

(defthm positionp-of-lex-?-integer-suffix.last/next-pos
  (b* (((mv acl2::?erp
            ?isuffix? ?last/next-pos ?new-parstate)
        (lex-?-integer-suffix parstate)))
    (positionp last/next-pos))
  :rule-classes :rewrite)

Theorem: parstatep-of-lex-?-integer-suffix.new-parstate

(defthm parstatep-of-lex-?-integer-suffix.new-parstate
  (implies (parstatep parstate)
           (b* (((mv acl2::?erp
                     ?isuffix? ?last/next-pos ?new-parstate)
                 (lex-?-integer-suffix parstate)))
             (parstatep new-parstate)))
  :rule-classes :rewrite)

Theorem: parsize-of-lex-?-integer-suffix-uncond

(defthm parsize-of-lex-?-integer-suffix-uncond
  (b* (((mv acl2::?erp
            ?isuffix? ?last/next-pos ?new-parstate)
        (lex-?-integer-suffix parstate)))
    (<= (parsize new-parstate)
        (parsize parstate)))
  :rule-classes :linear)

Theorem: parsize-of-lex-?-integer-suffix-cond

(defthm parsize-of-lex-?-integer-suffix-cond
  (b* (((mv acl2::?erp
            ?isuffix? ?last/next-pos ?new-parstate)
        (lex-?-integer-suffix parstate)))
    (implies (and (not erp) isuffix?)
             (<= (parsize new-parstate)
                 (1- (parsize parstate)))))
  :rule-classes :linear)