• 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-iconst/fconst

Lex an integer or floating constant.

Signature

(lex-iconst/fconst first-digit first-pos parstate) 
  → 
(mv erp const last-pos new-parstate)

Arguments

first-digit — Guard (dec-digit-char-p first-digit).

first-pos — Guard (positionp first-pos).

parstate — Guard (parstatep parstate).

Returns

const — Type (constp const).

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

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

This is called when we expect an integer or floating constant, after reading the first (decimal) digit of the constant. The first digit and its position are passed to this function.

If the first digit is a 0, we check the next character. If there is no next character, we have the octal constant 0. If instead the next character is x or X, we must have a hexadecimal constant, for which we call a separate function. If instead the next character is something else, we must have an octal integer or decimal floating constant: we put back the character and call a separate function.

If instead the first digit is 1 to 9, we must have a decimal integer or floating constant, for which we use a separate function.

Definitions and Theorems

Function: lex-iconst/fconst

(defun lex-iconst/fconst (first-digit first-pos parstate)
 (declare (xargs :stobjs (parstate)))
 (declare (xargs :guard (and (dec-digit-char-p first-digit)
                             (positionp first-pos)
                             (parstatep parstate))))
 (let ((__function__ 'lex-iconst/fconst))
  (declare (ignorable __function__))
  (b* (((reterr)
        (irr-const)
        (irr-position)
        parstate))
   (cond
    ((eql first-digit #\0)
     (b* (((erp char pos parstate)
           (read-char parstate)))
      (cond
       ((not char)
        (retok
         (const-int
             (make-iconst
                  :core (make-dec/oct/hex-const-oct :leading-zeros 1
                                                    :value 0)
                  :suffix? nil
                  :info nil))
         (position-fix first-pos)
         parstate))
       ((or (utf8-= char (char-code #\x))
            (utf8-= char (char-code #\X)))
        (b* ((hprefix (if (utf8-= char (char-code #\x))
                          (hprefix-locase-0x)
                        (hprefix-upcase-0x))))
          (lex-hex-iconst/fconst hprefix pos parstate)))
       (t (b* ((parstate (unread-char parstate)))
            (lex-oct-iconst-/-dec-fconst first-pos parstate))))))
    (t (lex-dec-iconst/fconst first-digit first-pos parstate))))))

Theorem: constp-of-lex-iconst/fconst.const

(defthm constp-of-lex-iconst/fconst.const
  (b* (((mv acl2::?erp
            ?const ?last-pos ?new-parstate)
        (lex-iconst/fconst first-digit first-pos parstate)))
    (constp const))
  :rule-classes :rewrite)

Theorem: positionp-of-lex-iconst/fconst.last-pos

(defthm positionp-of-lex-iconst/fconst.last-pos
  (b* (((mv acl2::?erp
            ?const ?last-pos ?new-parstate)
        (lex-iconst/fconst first-digit first-pos parstate)))
    (positionp last-pos))
  :rule-classes :rewrite)

Theorem: parstatep-of-lex-iconst/fconst.new-parstate

(defthm parstatep-of-lex-iconst/fconst.new-parstate
 (implies (parstatep parstate)
          (b* (((mv acl2::?erp
                    ?const ?last-pos ?new-parstate)
                (lex-iconst/fconst first-digit first-pos parstate)))
            (parstatep new-parstate)))
 :rule-classes :rewrite)

Theorem: parsize-of-lex-iconst/fconst-uncond

(defthm parsize-of-lex-iconst/fconst-uncond
  (b* (((mv acl2::?erp
            ?const ?last-pos ?new-parstate)
        (lex-iconst/fconst first-digit first-pos parstate)))
    (<= (parsize new-parstate)
        (parsize parstate)))
  :rule-classes :linear)