1 files changed, 44 insertions, 8 deletions
diff --git a/module/c/lex.scm b/module/c/lex.scm
index 34e52d88..0bde5c9e 100644
--- a/module/c/lex.scm
+++ b/module/c/lex.scm
@@ -43,8 +43,23 @@
 (define-peg-pattern integer all
   (and (or base-8 base-16 base-10) (? integer-suffix)))
 
+(define-peg-pattern float-suffix all
+  (* (or "f" "F" "l" "L")))
+
+(define-peg-pattern exponent all
+  (and (ignore (or "e" "E")) (? (or "+" "-")) base-10))
+
+;; Helper patterns for creating named groups in float
+(define-peg-pattern float-integer all base-10)
+(define-peg-pattern float-decimal all base-10)
+
+(define-peg-pattern float all
+  (or (and    float-integer                                exponent  (? float-suffix))
+      (and (? float-integer) (ignore ".") float-decimal (? exponent) (? float-suffix))
+      (and    float-integer  (ignore ".")               (? exponent) (? float-suffix))))
+
 (define-peg-pattern number body
-  (or integer))
+  (or float integer))
 
 (define-peg-pattern group all
   (and (ignore "(") expr (ignore ")")))
@@ -65,11 +80,16 @@
 (define-peg-pattern char all
   (and (ignore "'") (or escaped-char peg-any) (ignore "'")))
 
+(define-peg-pattern quot none "\"")
+
+(define-peg-pattern string all
+  (and quot (* (or escaped-char (and (not-followed-by "\"") peg-any))) quot))
 
 (define-peg-pattern* operator all
   `(or ,@(map symbol->string symbol-binary-operators)
        ,@(map (lambda (op) `(and ,(symbol->string op) ws))
-              wordy-binary-operators)))
+              wordy-binary-operators)
+       "?" ":"))
 
 ;; whitespace
 (define-peg-pattern ws none
@@ -89,17 +109,23 @@
               base-10-digit))))
 
 (define-peg-pattern prefix-operator all
-  (or "!" "~" "*" "&" "++" "--" "+" "-"))
+  ;; It's important that ++ and -- are BEFORE + and -
+  ;; otherwise the first + is found, leaving the second +, which fails
+  ;; to lex since it's an invalid token
+  ;; TODO sizeof can be written as a prefix operator
+  ;; (without parenthesis) if the operand is an expression.
+  (or "*" "&" "++" "--"
+      "!" "~" "+" "-"))
+
 
 ;;; Note that stacked pre or postfix operators without parenthesis
 ;;; dosen't work. So `*&C' is invalid, while `*(&C)' is valid.
 
 (define-peg-pattern prefix all
-  (and prefix-operator sp (or variable group funcall #; postfix
-                              )))
+  (and prefix-operator sp (or variable group funcall literal)))
 
 (define-peg-pattern postfix-operator all
-  (or "++" "--"))
+  (or "++" "--" "*"))
 
 (define-peg-pattern postfix all
   ;; literals can't be in-place incremented and decremented
@@ -111,15 +137,25 @@
   ;; first case is "same" as expr, but in different order to prevent
   ;; infinite self reference. Pre and postfix not here, solved by having
   ;; them before infix in expr
-  (and (or funcall postfix prefix group char number variable)
+  (and (or funcall postfix prefix group literal variable)
        sp operator sp expr))
 
 (define-peg-pattern funcall all
   (and variable sp group))
 
+(define-peg-pattern literal body
+  (or char string number))
+
 ;;; main parser
 (define-peg-pattern expr body
-  (+ (and sp (or infix postfix prefix funcall group char number variable)
+  (+ (and sp (or
+              ;; float must be BEFORE infix, otherwise 3.2 is parsed as (infix 3 (operator ".") 2)
+              ;; that however breaks the infix logic, meaning that floating point numbers can't be
+              ;; used in basic arithmetic.
+              ;; TODO remove all implicit order of operations handling in the lexer, and move it to
+              ;; the parser. This should also fix the case of typecasts being applied incorrectly.
+              float
+              infix postfix prefix funcall group literal variable)
           sp)))