[create a map of rawtypes to their respective C class, optimize some slow list lookups to use fast maps
John Meacham <john@repetae.net>**20051006065240] hunk ./DataConstructors.hs 146
-primitiveTable = concatMap f allCTypes ++ map g (snub $ snds allCTypes) where
+primitiveTable = concatMap f allCTypes ++ map g (snub $ map ( \ (_,b,_) -> b) allCTypes) where
hunk ./DataConstructors.hs 158
-    f (x,y) | x /= "Prelude.()" = [typeCons,dataCons] where
+    f (x,y,z) | z /= "void" = [typeCons,dataCons] where
hunk ./DataConstructors.hs 228
-    ELit (LitCons c [] _) | Just pt <- Prelude.lookup (show c) allCTypes -> return (c,pt)
+    ELit (LitCons c [] _) | Just pt <- Map.lookup c ctypeMap -> return (c,pt)
hunk ./E/PrimOpt.hs 3
+import List
+import Monad
+import qualified Data.Map as Map
+
hunk ./E/PrimOpt.hs 18
-import List
-import Monad
hunk ./E/PrimOpt.hs 19
+import PrimitiveOperators
hunk ./E/PrimOpt.hs 46
+rawMap = Map.fromList [ (rawType w,toAtom t) | (_,w,t) <- allCTypes]
+typ_float = toAtom "float"
+
hunk ./E/PrimOpt.hs 55
-        primopt (Operator "==" [ta,tb] tr) [e,(ELit (LitInt x t))] rt = return $ eCase e [Alt (LitInt x t) (ELit (LitInt 1 intt)) ] (ELit (LitInt 0 intt))
-        primopt (Operator "==" [ta,tb] tr) [(ELit (LitInt x t)),e] rt = return $ eCase e [Alt (LitInt x t) (ELit (LitInt 1 intt)) ] (ELit (LitInt 0 intt))
+        primopt (Operator "==" [ta,tb] tr) [e,(ELit (LitInt x t))] rt | Map.lookup t rawMap /= Just typ_float = return $ eCase e [Alt (LitInt x t) (ELit (LitInt 1 intt)) ] (ELit (LitInt 0 intt))
+        primopt (Operator "==" [ta,tb] tr) [(ELit (LitInt x t)),e] rt | Map.lookup t rawMap /= Just typ_float = return $ eCase e [Alt (LitInt x t) (ELit (LitInt 1 intt)) ] (ELit (LitInt 0 intt))
hunk ./Grin/FromE.hs 202
-    ] ++ [ (toAtom ('C':x), ([Ty $ toAtom y],TyNode)) | (x,y) <- allCTypes, y /= "void" ]
+    ] ++ [ (toAtom ('C':x), ([Ty $ toAtom y],TyNode)) | (x,y,_) <- allCTypes, y /= "void" ]
hunk ./Grin/FromE.hs 224
-    conv (ELit (LitInt i (ELit (LitCons n [] (ESort EStar))))) | Just pt <- Prelude.lookup (show n) allCTypes = ( Const (NodeC (toAtom $ 'C':show n) [(Lit i (Ty (toAtom pt)))]))
+    conv (ELit (LitInt i (ELit (LitCons n [] (ESort EStar))))) | Just pt <- Map.lookup n ctypeMap = ( Const (NodeC (toAtom $ 'C':show n) [(Lit i (Ty (toAtom pt)))]))
hunk ./Grin/FromE.hs 729
-    constant (ELit (LitInt i (ELit (LitCons n [] (ESort EStar))))) | Just pt <- Prelude.lookup (show n) allCTypes = (return $ Const (NodeC (toAtom $ 'C':show n) [(Lit i (Ty (toAtom pt)))]))
+    constant (ELit (LitInt i (ELit (LitCons n [] (ESort EStar))))) | Just pt <- Map.lookup n ctypeMap = (return $ Const (NodeC (toAtom $ 'C':show n) [(Lit i (Ty (toAtom pt)))]))
hunk ./data/PrimitiveOperators-in.hs 3
-module PrimitiveOperators(primitiveInsts,constantMethods,theMethods,allCTypes) where
+module PrimitiveOperators(primitiveInsts,constantMethods,theMethods,allCTypes,ctypeMap) where
hunk ./data/PrimitiveOperators-in.hs 5
-import Representation
+import Data.Monoid
+import qualified Data.Map as Map
+
+import CanType
+import C.Prims
hunk ./data/PrimitiveOperators-in.hs 11
+import E.TypeCheck()
hunk ./data/PrimitiveOperators-in.hs 13
-import C.Prims
-import VConsts
hunk ./data/PrimitiveOperators-in.hs 14
-import Data.Monoid
-import E.TypeCheck()
-import CanType
+import Representation
+import VConsts
+
+
+ctypeMap = Map.fromList [ (parseName TypeConstructor n,v) | (n,v,_) <- allCTypes ]
hunk ./op_process.prl 75
+my %rtype;
+sub rtype($) {
+    return $rtype{$_[0]}[0] if $rtype{$_[0]};
+    my $n = $_[0];
+    $n =~ s/\W/_/g;
+    $n = "rt_" . $n;
+    my $v = "$n = rawType \"$_[0]\"";
+    $rtype{$_[0]} = [$n,$v];
+    return $n;
+}
+
hunk ./op_process.prl 159
-    push @names, "(\"$d->[0]\", \"$d->[1]\")\n";
+    push @names, "(\"$d->[0]\", \"$d->[1]\", \"$d->[2]\")\n";
hunk ./op_process.prl 192
-push @names, "(\"Prelude.()\",\"void\")";
+push @names, "(\"Prelude.()\",\"void\",\"void\")";
hunk ./op_process.prl 199
+print join("\n",map { $_->[1] } values %rtype) . "\n\n";