Changed names to be uniquified based on their source position, and fixed the source position for things in pragmas

The second part of the patch is essential, given the first.  Otherwise names in different pragmas in the same file can overlap -- this already happened in oak!

data/CompState.hs

@@ -261,10 +261,7 @@ nameSource n = lookupName n >>* A.ndNameSource
 -- | Make a name unique by appending a suffix to it.
 makeUniqueName :: CSM m => Meta -> String -> m String
 makeUniqueName m s
-    =  do st <- get
+    = let mungedFile = munge $ show m in return $ s ++ "_" ++ mungedFile
-          let mungedFile = munge $ fromMaybe "" (metaFile m)
-          put $ st { csNameCounter = csNameCounter st + 1 }
-          return $ s ++ "_" ++ mungedFile ++ "_u" ++ show (csNameCounter st)
   where
     munge cs = [if c `elem` (['A'..'Z'] ++ ['a'..'z'] ++ ['0'..'9'])
                   then c

frontends/LexOccam.x

@@ -182,8 +182,8 @@ mkState code _ s = (Nothing, code)
 
 -- | Run the lexer, returning a list of tokens.
 -- (This is based on the `alexScanTokens` function that Alex provides.)
-runLexer :: Die m => String -> String -> m [Token]
+runLexer' :: Die m => (String, Int, Int) -> String -> m [Token]
-runLexer filename str = go (alexStartPos, '\n', str) 0
+runLexer' (filename, startLine, startCol) str = go (AlexPn 0 startLine startCol, '\n', str) 0
   where
     go inp@(pos@(AlexPn _ line col), _, str) code =
          case alexScan inp code of
@@ -204,5 +204,8 @@ runLexer filename str = go (alexStartPos, '\n', str) 0
                  metaColumn = col
                }
 
+runLexer :: Die m => String -> String -> m [Token]
+runLexer fn = runLexer' (fn, 1, 1)
+
 }
 

frontends/ParseOccam.hs

@@ -1370,8 +1370,8 @@ structuredTypeField
 --}}}
 --{{{ pragmas
 pragma :: OccParser ()
-pragma = do Pragma rawP <- genToken isPragma
+pragma = do m <- getPosition >>* sourcePosToMeta
-            m <- getPosition >>* sourcePosToMeta
+            Pragma rawP <- genToken isPragma
             let prag :: Maybe (Int, String)
                 prag = join $ find isJust
                  [ (matchRegex (mkRegex pt) rawP >>= listToMaybe) >>* (,) i
@@ -1409,7 +1409,7 @@ pragma = do Pragma rawP <- genToken isPragma
                   if pragmaType == 2
                     then do sPROC
                             n <- newProcName
-                            fs <- formalList >>* map fst
+                            fs <- formalList'
                             sEq
                             integer
                             return (n, ProcName, n, fs, A.Proc m (A.PlainSpec, A.PlainRec) fs (A.Skip m))
@@ -1436,7 +1436,9 @@ pragma = do Pragma rawP <- genToken isPragma
                   }
             case (prag, mprod) of
               (Just (_, pragStr), Just prod) -> do
-                toks <- runLexer "<unknown(pragma)>" pragStr
+                let column = metaColumn m + fromMaybe 0 (findIndex (=='\"') rawP)
+                toks <- runLexer' (fromMaybe "<unknown(pragma)>" $ metaFile m
+                                  , metaLine m, column) pragStr
                 cs <- getCompState
                 case runParser (prod >> getState) cs "" toks of
                   Left err -> warnP m WarnUnknownPreprocessorDirective $