diff options
| -rw-r--r-- | src/cljcc/analyzer.clj | 594 | ||||
| -rw-r--r-- | src/cljcc/exception.clj | 3 | ||||
| -rw-r--r-- | src/cljcc/parser.clj | 5 |
3 files changed, 404 insertions, 198 deletions
diff --git a/src/cljcc/analyzer.clj b/src/cljcc/analyzer.clj index 8eb0d42..d278ef4 100644 --- a/src/cljcc/analyzer.clj +++ b/src/cljcc/analyzer.clj @@ -2,7 +2,8 @@ (:require [cljcc.lexer :as l] [clojure.pprint :as pp] [cljcc.util :as u] - [cljcc.parser :as p])) + [cljcc.parser :as p] + [cljcc.exception :as exc])) (defn- unique-identifier ([] (unique-identifier "analyzer")) @@ -11,179 +12,258 @@ (defn- copy-identifier-map "Returns a copy of the identifier map. - Sets :from-current-block as false for every entry. Used when going into a inner scope." - [identifier-map] - (zipmap (keys identifier-map) - (map (fn [m] - (update m :from-current-block (fn [_] false))) - (vals identifier-map)))) + Sets :at-top-level false, as it's going inside a scope. ( Could be fn definition, compound statement ). + Sets :from-current-block as false for every symbol. Used when going into a inner scope." + [ident->symbol] + (let [set-from-current-block-as-false (fn [i->s] + (zipmap (keys i->s) + (map (fn [s] + (assoc s :from-current-block false)) + (vals i->s))))] + (-> ident->symbol + (dissoc :at-top-level) + set-from-current-block-as-false + (assoc :at-top-level false)))) (declare resolve-block) -(defn- resolve-exp [e identifier-map] +(defn- resolve-exp [e ident->symbol] (condp = (:exp-type e) :constant-exp e - :variable-exp (if (contains? identifier-map (:identifier e)) - (p/variable-exp-node (:name (get identifier-map (:identifier e)))) - (throw (ex-info "Undeclared variable seen." {:variable e}))) + :variable-exp (if (contains? ident->symbol (:identifier e)) + (p/variable-exp-node (:name (get ident->symbol (:identifier e)))) + (exc/analyzer-error "Undeclared variable seen." {:variable e})) :assignment-exp (let [left (:left e) right (:right e) op (:assignment-operator e) left-var? (= :variable-exp (:exp-type left))] (if left-var? - (p/assignment-exp-node (resolve-exp left identifier-map) - (resolve-exp right identifier-map) + (p/assignment-exp-node (resolve-exp left ident->symbol) + (resolve-exp right ident->symbol) op) - (throw (ex-info "Invalid lvalue." {:lvalue e})))) - :binary-exp (p/binary-exp-node (resolve-exp (:left e) identifier-map) - (resolve-exp (:right e) identifier-map) + (exc/analyzer-error "Invalid lvalue in assignment expression." {:lvalue e}))) + :binary-exp (p/binary-exp-node (resolve-exp (:left e) ident->symbol) + (resolve-exp (:right e) ident->symbol) (:binary-operator e)) - :unary-exp (p/unary-exp-node (:unary-operator e) (resolve-exp (:value e) identifier-map)) - :conditional-exp (p/conditional-exp-node (resolve-exp (:left e) identifier-map) - (resolve-exp (:middle e) identifier-map) - (resolve-exp (:right e) identifier-map)) + :unary-exp (p/unary-exp-node (:unary-operator e) (resolve-exp (:value e) ident->symbol)) + :conditional-exp (p/conditional-exp-node (resolve-exp (:left e) ident->symbol) + (resolve-exp (:middle e) ident->symbol) + (resolve-exp (:right e) ident->symbol)) :function-call-exp (let [fn-name (:identifier e) args (:arguments e)] - (if (contains? identifier-map fn-name) - (p/function-call-exp-node (:new-name (get identifier-map fn-name)) - (map #(resolve-exp % identifier-map) args)) + (if (contains? ident->symbol fn-name) + (p/function-call-exp-node (:new-name (get ident->symbol fn-name)) + (map #(resolve-exp % ident->symbol) args)) (throw (ex-info "Undeclared function !" {:function-name fn-name})))) - (throw (ex-info "Analyzer error. Invalid expression type" {:exp e})))) + (exc/analyzer-error "Invalid expression." {:exp e}))) (defn- resolve-optional-exp [e identifier-map] (if (nil? e) e (resolve-exp e identifier-map))) +(defn- resolve-file-scope-variable-declaration + "Adds file scope variable declaration to scope. + + Directly adds variable declaration to map as it is top level." + [{:keys [identifier] :as declaration} ident->symbol] + {:declaration declaration + :ident->symbol (assoc ident->symbol identifier {:new-name identifier + :name identifier + :from-current-scope true + :has-linkage true})}) + +(defn- resolve-local-variable-declaration + "Add local variable declaration. + + Validates for variables declared with same name. + Validates for variables declared from different scope, but with conflicting storage class." + [{:keys [identifier initial storage-class] :as declaration} ident->symbol] + (let [prev-entry (get ident->symbol identifier) + extern? (= storage-class :extern) + _ (when (and prev-entry (:from-current-scope prev-entry)) + (when (not (and (:has-linkage prev-entry) extern?)) + (exc/analyzer-error "Conflicting local declaration." {:declaration declaration})))] + (if extern? + {:declaration declaration + :ident->symbol (assoc ident->symbol identifier {:new-name identifier + :name identifier + :from-current-scope true + :has-linkage true})} + (let [unique-name (unique-identifier identifier) + updated-symbols (assoc ident->symbol identifier {:new-name unique-name + :name unique-name + :from-current-scope true + :has-linkage false}) + init-value (when initial (resolve-exp initial updated-symbols))] + {:declaration (p/variable-declaration-node unique-name storage-class init-value) + :ident->symbol updated-symbols})))) + (defn- resolve-variable-declaration "Resolves variable declarations. Ensures variable not declared twice in the current scope." - [{:keys [identifier initial] :as d} identifier-map] - (if (and (contains? identifier-map identifier) - (:from-current-block (get identifier-map identifier))) - (throw (ex-info "Analyzer error. Duplicate variable declaration." {:declaration d})) - (let [unique-name (unique-identifier identifier) - updated-identifier-map (assoc identifier-map identifier {:name unique-name - :from-current-block true - :has-linkage false}) - init-value (when initial (resolve-exp initial updated-identifier-map))] - {:declaration (p/variable-declaration-node unique-name init-value) - :identifier-map updated-identifier-map}))) - -(defn- resolve-parameter [{:keys [identifier] :as param} identifier-map] - (if (and (contains? identifier-map identifier) - (:from-current-block (get identifier-map identifier))) - (throw (ex-info "Analyzer error. Parameter name duplicated." {:parameter param})) + [decl {:keys [at-top-level] :as ident->symbol}] + (if at-top-level + (resolve-file-scope-variable-declaration decl ident->symbol) + (resolve-local-variable-declaration decl ident->symbol))) + +(defn- resolve-parameter [{:keys [identifier] :as param} ident->symbol] + (if (and (contains? ident->symbol identifier) + (:from-current-block (get ident->symbol identifier))) + (exc/analyzer-error "Parameter name duplicated." {:parameter param}) (let [unique-name (unique-identifier identifier) - updated-identifier-map (assoc identifier-map identifier {:name unique-name - :from-current-block true - :has-linkage false})] - {:parameter (p/variable-declaration-node unique-name) - :identifier-map updated-identifier-map}))) - -(defn- resolve-parameters [params identifier-map] + storage-class nil + updated-identifier-map (assoc ident->symbol identifier {:name unique-name + :from-current-block true + :has-linkage false})] + {:parameter (p/variable-declaration-node unique-name storage-class) + :ident->symbol updated-identifier-map}))) + +(defn- resolve-parameters [params ident->symbol] (reduce (fn [acc p] - (let [{:keys [parameter identifier-map]} (resolve-parameter p (:identifier-map acc))] + (let [{:keys [parameter ident->symbol]} (resolve-parameter p (:ident->symbol acc))] {:parameters (conj (:parameters acc) parameter) - :identifier-map identifier-map})) - {:parameters [] :identifier-map identifier-map} + :ident->symbol ident->symbol})) + {:parameters [] :ident->symbol ident->symbol} params)) (defn- resolve-function-declaration "Resolve function declaration. Ensures functions not declared twice in current scope with incorrect linkage." - [{:keys [identifier parameters return-type body] :as d} identifier-map] - (let [prev-entry (get identifier-map identifier) - already-declared-var? (and (contains? identifier-map identifier) - (:from-current-block (get identifier-map identifier)) + [{:keys [identifier storage-class parameters return-type body] :as d} ident->symbol] + (let [prev-entry (get ident->symbol identifier) + already-declared-var? (and (contains? ident->symbol identifier) + (:from-current-block (get ident->symbol identifier)) (not (:has-linkage prev-entry))) - illegally-redeclared? (and (contains? identifier-map identifier) + illegally-redeclared? (and (contains? ident->symbol identifier) (:from-current-scope prev-entry) (not (:has-linkage prev-entry))) - inside-function-definition? (:inside-function-definition (:inside-inner-scope identifier-map)) + static? (= :static storage-class) + inside-function-definition? (not (:at-top-level ident->symbol)) _ (when already-declared-var? - (throw (ex-info "Analyzer Error. Variable already declared in same scope." {:declaration d}))) + (exc/analyzer-error "Variable already declared in same scope." {:declaration d})) _ (when illegally-redeclared? - (throw (ex-info "Analyzer Error. Function duplicate declaration." {:declaration d}))) - updated-identifier-map (assoc identifier-map identifier {:new-name identifier - :name identifier - :from-current-block true - :from-current-scope true - :has-linkage true}) + (exc/analyzer-error "Function duplicate declaration." {:declaration d})) + updated-identifier-map (assoc ident->symbol identifier {:new-name identifier + :name identifier + :from-current-block true + :from-current-scope true + :has-linkage true}) inner-map (copy-identifier-map updated-identifier-map) - {new-params :parameters, inner-map :identifier-map} (resolve-parameters parameters inner-map) + {new-params :parameters, inner-map :ident->symbol} (resolve-parameters parameters inner-map) _ (when (and body inside-function-definition?) - (throw (ex-info "Analyzer Error. Nested function definition not allowed." {:declaration d}))) - new-body (when body (resolve-block body (assoc inner-map :inside-inner-scope {:inside-function-definition true})))] - {:declaration (p/function-declaration-node return-type identifier new-params (:block new-body)) - :identifier-map updated-identifier-map})) - -(defn- resolve-declaration [{:keys [declaration-type] :as d} identifier-map] + (exc/analyzer-error "Nested function definition not allowed." {:declaration d + :ident->symbol ident->symbol})) + _ (when (and inside-function-definition? static?) + (exc/analyzer-error "Nested static function declarations cannot exist." {:declaration d})) + new-body (when body (resolve-block body inner-map))] + {:declaration (p/function-declaration-node return-type storage-class identifier new-params (:block new-body)) + :ident->symbol updated-identifier-map})) + +(defn- resolve-declaration [{:keys [declaration-type] :as d} ident->symbol] (condp = declaration-type - :variable (resolve-variable-declaration d identifier-map) - :function (resolve-function-declaration d identifier-map) + :variable (resolve-variable-declaration d ident->symbol) + :function (resolve-function-declaration d ident->symbol) (throw (ex-info "Analyzer Error. Invalid declaration type." {:declaration d})))) -(defn- resolve-for-init [for-init var-mp] +(defn- resolve-for-init [for-init ident->symbol] (if (= (:type for-init) :declaration) - (resolve-declaration for-init var-mp) - (resolve-optional-exp for-init var-mp))) - -(defn- resolve-statement [s mp] - (condp = (:statement-type s) - :return (p/return-statement-node (resolve-exp (:value s) mp)) - :expression (p/expression-statement-node (resolve-exp (:value s) mp)) - :if (if (:else-statement s) - (p/if-statement-node (resolve-exp (:condition s) mp) - (resolve-statement (:then-statement s) mp) - (resolve-statement (:else-statement s) mp)) - (p/if-statement-node (resolve-exp (:condition s) mp) - (resolve-statement (:then-statement s) mp))) - :break s - :continue s - :while (p/while-statement-node (resolve-exp (:condition s) mp) - (resolve-statement (:body s) mp)) - :do-while (p/do-while-statement-node (resolve-exp (:condition s) mp) - (resolve-statement (:body s) mp)) - :for (let [new-identifier-map (copy-identifier-map mp) - for-init (resolve-for-init (:init s) new-identifier-map) - new-var-map (if (:declaration for-init) - (:identifier-map for-init) - new-identifier-map) ; updates new-identifier-map so that include possible - ; variable declaration - for-init (if (:declaration for-init) - (:declaration for-init) - for-init) - condition (resolve-optional-exp (:condition s) new-var-map) - post (resolve-optional-exp (:post s) new-var-map) - body (resolve-statement (:body s) new-var-map)] - (p/for-statement-node for-init condition post body)) - :compound (let [updated-mp (copy-identifier-map mp)] - (p/compound-statement-node (:block (resolve-block (:block s) updated-mp)))) - :empty (p/empty-statement-node) - (throw (ex-info "Analyzer error. Invalid statement." {:statement s})))) - -(defn- resolve-block-item [{:keys [type] :as item} identifier-map] + (resolve-declaration for-init ident->symbol) + (resolve-optional-exp for-init ident->symbol))) + +(defmulti resolve-statement + "Resolves statements in a given scope. + + Scope here refers to the ident->symbol map, which holds declarations + visisble to statement at this time. + + Dispatches based on the type of statement. + + Returns statement after recursively resolving all expressions and statements. + " + (fn [statement _ident->symbol] + (:statement-type statement))) + +(defmethod resolve-statement :default [statement _] + (exc/analyzer-error "Invalid statement." {:statement statement})) + +(defmethod resolve-statement :return [{:keys [value]} ident->symbol] + (p/return-statement-node (resolve-exp value ident->symbol))) + +(defmethod resolve-statement :break [statement _] + statement) + +(defmethod resolve-statement :continue [statement _] + statement) + +(defmethod resolve-statement :empty [statement _] + statement) + +(defmethod resolve-statement :expression [{:keys [value]} ident->symbol] + (p/expression-statement-node (resolve-exp value ident->symbol))) + +(defmethod resolve-statement :if [{:keys [condition then-statement else-statement]} ident->symbol] + (if else-statement + (p/if-statement-node (resolve-exp condition ident->symbol) + (resolve-statement then-statement ident->symbol) + (resolve-statement else-statement ident->symbol)) + (p/if-statement-node (resolve-exp condition ident->symbol) + (resolve-statement then-statement ident->symbol)))) + +(defmethod resolve-statement :while [{:keys [condition body]} ident->symbol] + (p/while-statement-node (resolve-exp condition ident->symbol) + (resolve-statement body ident->symbol))) + +(defmethod resolve-statement :do-while [{:keys [condition body]} ident->symbol] + (p/do-while-statement-node (resolve-exp condition ident->symbol) + (resolve-statement body ident->symbol))) + +(defmethod resolve-statement :for [{:keys [init condition post body]} ident->symbol] + (let [for-scope-identifier-map (copy-identifier-map ident->symbol) + resolved-for-init (resolve-for-init init for-scope-identifier-map) + for-scope-identifier-map (if (:declaration resolved-for-init) ; updates symbol map if for initializer is declaration + (:ident->symbol resolved-for-init) + for-scope-identifier-map) + resolved-for-init (if (:declaration resolved-for-init) ; getting the underlying declaration, if it is + (:declaration resolved-for-init) + resolved-for-init) + condition (resolve-optional-exp condition for-scope-identifier-map) + post (resolve-optional-exp post for-scope-identifier-map) + body (resolve-statement body for-scope-identifier-map)] + (p/for-statement-node resolved-for-init condition post body))) + +(defmethod resolve-statement :compound [{:keys [block]} ident->symbol] + (p/compound-statement-node (:block (resolve-block block (copy-identifier-map ident->symbol))))) + +(defn- resolve-block-item [{:keys [type] :as item} ident->symbol] (condp = type - :declaration (let [v (resolve-declaration item identifier-map)] + :declaration (let [v (resolve-declaration item ident->symbol)] {:block-item (:declaration v) - :identifier-map (:identifier-map v)}) - :statement {:block-item (resolve-statement item identifier-map) - :identifier-map identifier-map} - (throw (ex-info "Analyzer Error. Invalid statement/declaration." {item item})))) + :ident->symbol (:ident->symbol v)}) + :statement {:block-item (resolve-statement item ident->symbol) + :ident->symbol ident->symbol} + (exc/analyzer-error "Invalid statement/declaration type." item))) (defn- resolve-block + "Resolves a block with a given symbol table. + + ident->symbol holds identifier to symbol mapping. + Symbol contains the type information, generated variable name etc. + + | key | description | + |----------------|-------------| + |`:at-top-level` | Is current level top or not ( default true)|" ([block] - (resolve-block block {})) - ([block identifier-map] + (resolve-block block {:at-top-level true})) + ([block ident->symbol] (reduce (fn [acc block-item] - (let [v (resolve-block-item block-item (:identifier-map acc))] + (let [v (resolve-block-item block-item (:ident->symbol acc))] {:block (conj (:block acc) (:block-item v)) - :identifier-map (:identifier-map v)})) + :ident->symbol (:ident->symbol v)})) {:block [] - :identifier-map identifier-map} + :ident->symbol ident->symbol} block))) (defn- annotate-label [m l] @@ -244,88 +324,202 @@ (defn- typecheck-exp "Returns the expression itself, after typechecking all subexpressions." - [{:keys [exp-type] :as e} decl-name->symbol] + [{:keys [exp-type] :as e} ident->symbol] (condp = exp-type :constant-exp e :variable-exp (let [identifier (:identifier e) - variable-type (:variable-type (get decl-name->symbol identifier)) - _ (when (not (= :int variable-type)) - (throw (ex-info "Analyzer Error. Function name used as variable." {:exp e})))] + var? (= :variable (:type (get ident->symbol identifier))) + _ (when (not var?) + (exc/analyzer-error "Function name used as variable." {:exp e :ident->symbol ident->symbol}))] e) :assignment-exp (do - (typecheck-exp (:left e) decl-name->symbol) - (typecheck-exp (:right e) decl-name->symbol) + (typecheck-exp (:left e) ident->symbol) + (typecheck-exp (:right e) ident->symbol) e) :binary-exp (do - (typecheck-exp (:left e) decl-name->symbol) - (typecheck-exp (:right e) decl-name->symbol) + (typecheck-exp (:left e) ident->symbol) + (typecheck-exp (:right e) ident->symbol) e) :unary-exp (do - (typecheck-exp (:value e) decl-name->symbol) + (typecheck-exp (:value e) ident->symbol) e) :conditional-exp (do - (typecheck-exp (:left e) decl-name->symbol) - (typecheck-exp (:right e) decl-name->symbol) - (typecheck-exp (:middle e) decl-name->symbol) + (typecheck-exp (:left e) ident->symbol) + (typecheck-exp (:right e) ident->symbol) + (typecheck-exp (:middle e) ident->symbol) e) - :function-call-exp (let [symbol (decl-name->symbol (:identifier e)) - _ (when (= :int (:variable-type symbol)) + :function-call-exp (let [symbol (ident->symbol (:identifier e)) + _ (when (not= :function (:type symbol)) (throw (ex-info "Analyzer Error. Variable used as function name." {:exp e}))) - _ (when (not (= (count (:arguments e)) (:param-count symbol))) + _ (when (not= (count (:arguments e)) (:param-count symbol)) (throw (ex-info "Analyzer Error. Function called with the wrong number of arguments." {:exp e}))) - _ (map #(typecheck-exp % decl-name->symbol) (:arguments e))] + _ (map #(typecheck-exp % ident->symbol) (:arguments e))] e) (throw (ex-info "Analyzer error. Invalid expression type passed to typechecker." {:exp e})))) -(defn- variable-symbol [variable-type] - {:variable-type variable-type}) -(defn- function-symbol [param-count defined?] - {:param-count param-count - :defined? defined?}) +(defn- fun-attrs [defined? global?] + {:type :fun + :defined? defined? + :global? global?}) + +(defn- static-attrs [initial-value global?] + {:type :static + :initial-value initial-value + :global? global?}) -(defn- add-parameters [params decl-name->symbol] - (if (= 0 (count params)) - decl-name->symbol +(defn- local-attrs [] + {:type :local}) + +(defn- variable-symbol [variable-type attrs] + {:type :variable + :variable-type variable-type + :attrs attrs}) + +(defn- function-symbol [param-count attrs] + {:type :function + :param-count param-count + :attrs attrs}) + +(defn- add-parameters [params ident->symbol] + (if (zero? (count params)) + ident->symbol (apply assoc - decl-name->symbol - (flatten (map (fn [p] [(:identifier p) (variable-symbol :int)]) params))))) + ident->symbol + (flatten (map (fn [p] [(:identifier p) (variable-symbol :int (local-attrs))]) params))))) (declare typecheck-block) -(defn- typecheck-declaration [{:keys [declaration-type identifier] :as d} decl-name->symbol] - (condp = declaration-type - :variable (let [updated-decl-name->symbol (assoc decl-name->symbol identifier (variable-symbol :int)) - _ (when (:initial d) (typecheck-exp (:initial d) updated-decl-name->symbol))] - {:declaration d - :decl-name->symbol updated-decl-name->symbol}) - :function (let [param-count (count (:parameters d)) - has-body? (not (empty? (:body d))) - previously-declared? (contains? decl-name->symbol identifier) - _ (when previously-declared? - (let [old-symbol (get decl-name->symbol identifier) - _ (when (not= param-count (:param-count old-symbol)) - (throw (ex-info "Analyzer Error. Incompatible function declarations." {:declaration d}))) - _ (when (and (:defined? old-symbol) has-body?) - (throw (ex-info "Analyzer Error. Function is defined more than once." {:declaration d})))])) - updated-decl-name->symbol (assoc decl-name->symbol - identifier - (function-symbol param-count (or (:defined? (get decl-name->symbol identifier)) has-body?)))] - (if has-body? - (let [with-parameters-symbols (add-parameters (:parameters d) updated-decl-name->symbol) - with-body-symbols (typecheck-block (:body d) with-parameters-symbols)] - {:declaration d - :decl-name->symbol (:decl-name->symbol with-body-symbols)}) - {:declaration d - :decl-name->symbol updated-decl-name->symbol})) - (throw (ex-info "Analyzer Error. Invalid declaration for typechecker." {:declaration d})))) +(defn- validate-fn-decl-and-return-updated-attrs + [cur-decl old-decl] + (let [param-count (count (:parameters cur-decl)) + old-param-count (:param-count old-decl) + has-body? (seq (:body param-count)) + _ (when (not= param-count old-param-count) + (exc/analyzer-error "Incompatible function declarations." {:declaration1 old-decl + :declaration2 cur-decl})) + defined? (:defined? (:attrs old-decl)) + _ (when (and defined? has-body?) + (exc/analyzer-error "Function is defined more than once." {:declaration cur-decl})) + old-global? (:global? (:attrs old-decl)) + _ (when (and old-global? (= :static (:storage-class cur-decl))) + (exc/analyzer-error "Static function definition follows non static." {:declaration cur-decl}))] + {:defined? defined? + :global? old-global?})) + +(defn- typecheck-function-declaration + [{:keys [identifier parameters body storage-class] :as decl} ident->symbol] + (let [param-count (count parameters) + body? (seq body) + old-decl (get ident->symbol identifier) + {defined? :defined? + global? :global?} (if old-decl + (validate-fn-decl-and-return-updated-attrs decl old-decl) + {:defined? false + :global? (not= :static storage-class)}) + attrs (fun-attrs (or defined? (boolean body?)) global?) + updated-symbol-map (assoc ident->symbol identifier + (function-symbol param-count attrs))] + (if body? + (let [with-parameter-symbols (add-parameters parameters updated-symbol-map) + with-body-symbols (typecheck-block body (assoc with-parameter-symbols + :at-top-level false))] + {:declaration decl + :ident->symbol (assoc (:ident->symbol with-body-symbols) :at-top-level true)}) + {:declaration decl + :ident->symbol updated-symbol-map}))) + +(defn- get-initial-value [decl] + (cond + (= :constant-exp (:exp-type (:initial decl))) {:type :initial + :value (:value (:initial decl))} + (nil? (:initial decl)) (if (= :extern (:storage-class decl)) + {:type :no-initializer} + {:type :tentative}) + :else (exc/analyzer-error "Non-constant initializer!" decl))) + +(defn- validate-file-scope-decl-return-attrs [cur-decl old-decl] + (let [_ (when (not= :variable (:declaration-type old-decl)) + (exc/analyzer-error "Function redeclared as variable." {:declaration1 old-decl + :declaration2 cur-decl})) + global? (not= :static (:storage-class cur-decl)) + global? (cond + (= :extern (:storage-class cur-decl)) (:global? (:attrs old-decl)) + (not= global? (:global? (:attrs old-decl))) (exc/analyzer-error "Conflicting variable linkage." {:declaration1 old-decl + :declaration2 cur-decl}) + :else global?) + initial-value (get-initial-value cur-decl) + initial-value (cond + (= + :initial + (get-in old-decl [:attrs :initial-value :type])) (if (= (:type initial-value) :initial) + (exc/analyzer-error "Conflivting file scope variable definition." {:declarartion1 old-decl + :declaration2 cur-decl}) + (get-in old-decl [:attrs :initial-value])) + (and + (= :tentative (get-in old-decl [:attrs :initial-value :type])) + (not= :initial (:type initial-value))) {:type :tentative} + :else initial-value)] + {:global? global? + :initial-value initial-value})) + +(defn- typecheck-file-scope-variable-declaration + [{:keys [identifier storage-class ] :as d} ident->symbol] + (let [old-decl (get ident->symbol identifier) + global? (not= :static storage-class) + initial-value (get-initial-value d) + {global? :global? + initial-value :initial-value} (if old-decl + (validate-file-scope-decl-return-attrs d old-decl) + {:global? global? + :initial-value initial-value})] + {:declaration d + :ident->symbol (assoc ident->symbol + identifier + (variable-symbol :int (static-attrs initial-value global?)))})) + +(defn- typecheck-local-scope-variable-declaration + [{:keys [identifier storage-class initial] :as d} ident->symbol] + (cond + (= :extern storage-class) (let [_ (when (not (nil? initial)) + (exc/analyzer-error "Initializer on local extern variable declaration." d)) + old-decl (get ident->symbol identifier) + _ (when (and old-decl (not= :variable (:declaration-type old-decl))) + (exc/analyzer-error "Function redeclared as variable." {:declaration1 old-decl + :declaration2 d}))] + {:declaration d + :ident->symbol (assoc ident->symbol + identifier + (variable-symbol :int (static-attrs {:type :no-initializer} true)))}) + (= :static storage-class) (let [initial-value (cond + (= :constant-exp (:exp-type initial)) {:type :initial + :value (:value initial)} + (nil? initial) {:type :initial + :value 0} + :else (exc/analyzer-error "Non-constant initializer on local static variable." d))] + {:declaration d + :ident->symbol (assoc ident->symbol + identifier + (variable-symbol :int (static-attrs initial-value false)))}) + :else (let [updated-symbols (assoc ident->symbol identifier (variable-symbol :int (local-attrs))) + _ (when initial (typecheck-exp initial updated-symbols))] + {:declaration d + :ident->symbol updated-symbols}))) + +(defn- typecheck-declaration [{:keys [declaration-type identifier] :as d} ident->symbol] + (let [at-top-level? (:at-top-level ident->symbol)] + (condp = declaration-type + :variable (if at-top-level? + (typecheck-file-scope-variable-declaration d ident->symbol) + (typecheck-local-scope-variable-declaration d ident->symbol)) + :function (typecheck-function-declaration d ident->symbol) + (throw (ex-info "Analyzer Error. Invalid declaration for typechecker." {:declaration d}))))) (defn- typecheck-optional-expression [e decl-name->symbol] (if (nil? e) e (typecheck-exp e decl-name->symbol))) - (defn- typecheck-for-init [for-init decl-name->symbol] (if (= (:type for-init) :declaration) (typecheck-declaration for-init decl-name->symbol) @@ -373,25 +567,33 @@ :empty s (throw (ex-info "Analyzer Error. Invalid statement type in typechecker." {:statement s})))) -(defn- typecheck-item [{:keys [type] :as item} decl-name->symbol] +(defn- typecheck-item [{:keys [type] :as item} ident->symbol] (condp = type - :declaration (let [v (typecheck-declaration item decl-name->symbol)] + :declaration (let [v (typecheck-declaration item ident->symbol)] {:block-item (:declaration v) - :decl-name->symbol (:decl-name->symbol v)}) - :statement {:block-item (typecheck-statement item decl-name->symbol) - :decl-name->symbol decl-name->symbol} - (throw (ex-info "Analyzer Error. Invalid statement/declaration." {item item})))) + :ident->symbol (:ident->symbol v)}) + :statement {:block-item (typecheck-statement item ident->symbol) + :ident->symbol ident->symbol} + (exc/analyzer-error "Invalid statement/declaration." {item item}))) (defn- typecheck-block + "Typechecks a block with a given symbol table. + + ident->symbol holds identifier to symbol mapping. + Symbol contains the type information, generated variable name etc. + + | key | description | + |----------------|-------------| + |`:at-top-level` | Is current level top or not ( default true)|" ([block] - (typecheck-block block {})) - ([block decl-name->symbol] + (typecheck-block block {:at-top-level true})) + ([block ident->symbol] (reduce (fn [acc item] - (let [v (typecheck-item item (:decl-name->symbol acc))] + (let [v (typecheck-item item (:ident->symbol acc))] {:block (conj (:block acc) (:block-item v)) - :decl-name->symbol (:decl-name->symbol v)})) + :ident->symbol (:ident->symbol v)})) {:block [] - :decl-name->symbol decl-name->symbol} + :ident->symbol ident->symbol} block))) (defn validate [ast] @@ -409,16 +611,22 @@ (comment - (pp/pprint (validate-from-src " -int foo(void); -int main(void) { -return foo(); +int twice(int x){ + return 2 * x; } -int foo(void) { -return 3; +") + + (validate-from-src + " +int main(void) { + int a = 3; + { + int a = a = 4; + return a; + } } -")) +") - ()) + ()) diff --git a/src/cljcc/exception.clj b/src/cljcc/exception.clj index 6eec308..9ea5f31 100644 --- a/src/cljcc/exception.clj +++ b/src/cljcc/exception.clj @@ -7,3 +7,6 @@ (defn parser-error [msg data] (throw (ex-info msg (merge {:error/type :parser} data)))) + +(defn analyzer-error [msg data] + (throw (ex-info msg (merge {:error/type :analyzer} data)))) diff --git a/src/cljcc/parser.clj b/src/cljcc/parser.clj index 84e681c..4ae441a 100644 --- a/src/cljcc/parser.clj +++ b/src/cljcc/parser.clj @@ -26,11 +26,6 @@ [_ tokens] (expect end-kind tokens)] [e tokens]))) -(defn- keyword->type [k] - (condp = k - :kw-int "int" - (throw (ex-info "Parser Error. Unsupported type." {:keyword k})))) - (defn- expect "Expects the first token in list to be of given kind. |