language-ats 1.3.0.0 → 1.5.0.0

raw patch · 44 files changed

+13565/−107 lines, 44 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• language-ats.cabal +3/−1
• src/Language/ATS/Lexer.x +2/−2
• src/Language/ATS/Parser.y +36/−25
• src/Language/ATS/PrettyPrint.hs +52/−47
• src/Language/ATS/Types.hs +27/−18
• src/Language/ATS/Types/Lens.hs +2/−1
• test/data/fib-thm.dats +9/−4
• test/data/levenshtein.out +2/−2
• test/data/levenshtein2.out +7/−7
• test/data/stdlib/arith_prf.out +276/−0
• test/data/stdlib/arith_prf.sats +309/−0
• test/data/stdlib/array.out +594/−0
• test/data/stdlib/array.sats +684/−0
• test/data/stdlib/arrayref.out +587/−0
• test/data/stdlib/arrayref.sats +676/−0
• test/data/stdlib/basics_dyn.out +884/−0
• test/data/stdlib/basics_dyn.sats +918/−0
• test/data/stdlib/basics_gen.out +148/−0
• test/data/stdlib/basics_gen.sats +175/−0
• test/data/stdlib/bool.out +63/−0
• test/data/stdlib/checkast.out +123/−0
• test/data/stdlib/checkast.sats +120/−0
• test/data/stdlib/filebas.out +360/−0
• test/data/stdlib/filebas.sats +358/−0
• test/data/stdlib/gnumber.out +128/−0
• test/data/stdlib/gnumber.sats +127/−0
• test/data/stdlib/gorder.out +139/−0
• test/data/stdlib/gorder.sats +172/−0
• test/data/stdlib/integer_fixed.out +1436/−0
• test/data/stdlib/integer_fixed.sats +566/−0
• test/data/stdlib/integer_long.out +919/−0
• test/data/stdlib/integer_long.sats +425/−0
• test/data/stdlib/integer_ptr.out +446/−0
• test/data/stdlib/integer_ptr.sats +215/−0
• test/data/stdlib/integer_short.out +420/−0
• test/data/stdlib/integer_short.sats +195/−0
• test/data/stdlib/integer_size.out +569/−0
• test/data/stdlib/integer_size.sats +296/−0
• test/data/stdlib/intrange.out +109/−0
• test/data/stdlib/intrange.sats +106/−0
• test/data/stdlib/option_vt.out +107/−0
• test/data/stdlib/option_vt.sats +129/−0
• test/data/stdlib/unsafe.out +332/−0
• test/data/stdlib/unsafe.sats +314/−0

@@ -1,6 +1,6 @@ cabal-version: 1.18 name: language-ats-version: 1.3.0.0+version: 1.5.0.0 license: BSD3 license-file: LICENSE copyright: Copyright: (c) 2018 Vanessa McHale@@ -16,6 +16,8 @@     test/data/*.dats     test/data/*.sats     test/data/*.out+    test/data/stdlib/*.sats+    test/data/stdlib/*.out extra-doc-files: README.md  source-repository head

@@ -83,8 +83,8 @@ @signature = ":<" @inner_signature_mult ">" | ":" @func_type = "->" | "-<" @inner_signature_mult ">" -@at_brace = \@ ($white | @block_comment)* \{-@at_tuple = \@ ($white | @block_comment)* \(+@at_brace = \@ (@block_comment)* \{+@at_tuple = \@ (@block_comment)* \(  @box_tuple = \' ($white | @block_comment)* \( @box_record = \' ($white | @block_comment)* \{

@@ -63,6 +63,7 @@ %nonassoc mutateEq %nonassoc maybeProof %nonassoc prfTransform+%nonassoc raise  %token     fun { Keyword $$ KwFun }@@ -253,7 +254,7 @@ alt(p,q) : p { $1 }          | q { $1 } -ATS : Declarations { ATS $1 }+ATS : Declarations { ATS (reverse $1) }  -- | Parse declarations in a list Declarations : { [] } @@ -290,18 +291,19 @@      | Existential { Ex $1 Nothing }      | Universal Type { ForA $1 $2 }      | Type at StaticExpression { AtExpr $2 $1 $3 }-     | at Type { AtType $1 $2 }+     | at lsqbracket Type rsqbracket lsqbracket StaticExpression rsqbracket { ArrayType $1 $3 $6 }      | atbrace Records rbrace { AnonymousRecord $1 $2 }-     | openParen TypeIn vbar Type closeParen { ProofType $1 $2 $4 }+     | openParen TypeIn vbar TypeIn closeParen { ProofType $1 $2 $4 }      | identifierSpace identifier { Dependent (Unqualified $ to_string $1) [Named (Unqualified $ to_string $2)] }      | openParen TypeIn closeParen { Tuple $1 (toList $2) }      | openParen TypeIn closeParen lineComment { Tuple $1 (toList $2) }      | boxTuple TypeIn closeParen { BoxTuple $1 $2 }      | boxTuple TypeIn closeParen lineComment { BoxTuple $1 $2 }      | openParen Type closeParen { ParenType $1 $2 }-     | openParen TypeIn rbrace {% left $ Expected $3 ")" "}" }-     | doubleParens { NoneType $1 }+     | addr { AddrType $1 }+     | doubleParens { Tuple $1 mempty }      | Type where IdentifierOr SortArgs eq Type { WhereType $2 $1 $3 $4 $6 }+     | openParen TypeIn rbrace {% left $ Expected $3 ")" "}" }      | dollar {% left $ Expected $1 "Type" "$" }      | identifierSpace identifier openParen {% left $ Expected (token_posn $2) "Static integer expression" (to_string $2) }      | Type identifierSpace {% left $ Expected (token_posn $2) "," (to_string $2) }@@ -321,7 +323,7 @@         | exclamation IdentifierOr colon {% left $ OneOf $3 [",", ")"] ":" }  Arg : TypeArg { $1 }-    | StaticExpression { Arg (Second (ConcreteType $1)) }+    | StaticExpression { Arg (Second (ConcreteType $1)) } -- TODO: have some sort of stop showing bound variables that we can use to disambiguate types vs. static expressions?  -- | Parse a literal Literal : uintLit { UintLit $1 }@@ -352,6 +354,7 @@         | at Pattern { AtPattern $1 $2 }         | identifier Universals Pattern { UniversalPattern (token_posn $1) (to_string $1) $2 $3 }         | identifierSpace Universals Pattern { UniversalPattern (token_posn $1) (to_string $1) $2 $3 }+        | Pattern customOperator Pattern { BinPattern (token_posn $2) (SpecialInfix (token_posn $2) (to_string $2)) $1 $3 }         | Pattern as Pattern { As $2 $1 $3 }         | Existential Pattern { ExistentialPattern $1 $2 }         | minus {% left $ Expected $1 "Pattern" "-" }@@ -441,6 +444,8 @@ StaticExpression : Name { StaticVal $1 }                  | StaticExpression BinOp StaticExpression { StaticBinary $2 $1 $3 }                  | intLit { StaticInt $1 }+                 | hexLit { StaticHex $1 }+                 | string { SString $1 }                  | doubleParens { StaticVoid $1 }                  | sif StaticExpression then StaticExpression else StaticExpression { Sif $2 $4 $6 }                  | identifierSpace { StaticVal (Unqualified $ to_string $1) }@@ -450,9 +455,11 @@                  | StaticExpression semicolon StaticExpression { SPrecede $1 $3 }                  | UnOp StaticExpression { SUnary $1 $2 }                  | identifierSpace doubleParens { SCall (Unqualified $ to_string $1) [] }+                 | identifier doubleParens { SCall (Unqualified $ to_string $1) [] }                  | let StaticDecls comment_after(in) end { SLet $1 $2 Nothing }                  | let StaticDecls in StaticExpression end { SLet $1 $2 (Just $4) }                  | openParen StaticExpression closeParen { $2 }+                 | openParen lineComment StaticExpression closeParen { $3 }                  | case StaticExpression of StaticCase { SCase $1 $2 $4 }  -- | Parse an expression that can be called without parentheses@@ -556,8 +563,8 @@  Implicits : lspecial TypeIn rbracket { [toList $2] }           | Implicits lspecial TypeIn rbracket { toList $3 : $1 }-          | doubleBrackets { [[Named (Unqualified "")]] }-          | Implicits doubleBrackets { [Named (Unqualified "")] : $1 }+          | doubleBrackets { [[]] }+          | Implicits doubleBrackets { [] : $1 }           | lbracket TypeIn rbracket { [toList $2] }           | Implicits lspecial TypeIn rbracket { toList $3 : $1 }           @@ -594,13 +601,13 @@      | dollar {% left $ Expected $1 "Name" "$" }  -- | Parse a list of values in a record-RecordVal : IdentifierOr eq Expression { [($1, $3)] }-          | RecordVal comma IdentifierOr eq Expression { ($3, $5) : $1 }+RecordVal : IdentifierOr eq Expression { ($1, $3) :| [] }+          | RecordVal comma IdentifierOr eq Expression { ($3, $5) :| toList $1 }           | IdentifierOr eq comma {% left $ Expected $3 "Expression" "," }  -- | Parse a list of types in a record-Records : IdentifierOr eq Type { [($1, $3)] }-        | Records comma IdentifierOr eq Type { ($3, $5) : $1 }+Records : IdentifierOr eq Type { ($1, $3) :| [] }+        | Records comma IdentifierOr eq Type { ($3, $5) :| toList $1 }  IdentifiersIn : comma_sep(IdentifierOr) { toList $1 } @@ -615,11 +622,11 @@         | vbar Universals IdentifierOr openParen StaticExpressionsIn closeParen OfType { Leaf $2 $3 $5 $7 } -- FIXME could also be e.g. '0' (static expression)  -- | Parse all constructors of a sum type-Leaves : SumLeaf { [$1] }-       | Leaves SumLeaf { $2 : $1 }-       | Universals identifierSpace of Type { [Leaf $1 (to_string $2) [] (Just $4)] }-       | Universals identifier { [Leaf $1 (to_string $2) [] Nothing] }-       | Universals identifier openParen StaticExpressionsIn closeParen OfType { [Leaf $1 (to_string $2) $4 $6] }+Leaves : SumLeaf { $1 :| [] }+       | Leaves SumLeaf { $2 :| toList $1 }+       | Universals identifierSpace of Type { Leaf $1 (to_string $2) [] (Just $4) :| [] }+       | Universals identifier { Leaf $1 (to_string $2) [] Nothing :| [] }+       | Universals identifier openParen StaticExpressionsIn closeParen OfType { Leaf $1 (to_string $2) $4 $6 :| [] }        | dollar {% left $ Expected $1 "|" "$" }  PreUniversals : { [] }@@ -701,7 +708,7 @@         | { Nothing }  -- | Parse a type signature and optional function body-PreFunction : FunName openParen Args closeParen OptType OptExpression { (PreF $1 (fmap fst $5) [] [] (Just $3) (fmap snd $5) Nothing $6) }+PreFunction : FunName openParen Args closeParen OptType OptExpression { PreF $1 (fmap fst $5) [] [] (Just $3) (fmap snd $5) Nothing $6 }             | FunName Universals OptTermetric OptType OptExpression { PreF $1 (fmap fst $4) [] $2 Nothing (fmap snd $4) $3 $5 }             | FunName Universals OptTermetric doubleParens OptType OptExpression { PreF $1 (fmap fst $5) [] $2 (Just []) (fmap snd $5) $3 $6 }             | FunName Universals OptTermetric openParen Args closeParen OptType OptExpression { PreF $1 (fmap fst $7) [] $2 (Just $5) (fmap snd $7) $3 $8 }@@ -720,13 +727,15 @@         | sortdef IdentifierOr eq Sort { SortDef $1 $2 (Left $4) }         | sortdef IdentifierOr eq Universal { SortDef $1 $2 (Right $4) } -StaticDef : eq Type { Right $2 }+StaticDef : eq Type { Right (Nothing, $2) }           | eq StaticExpression MaybeAnnot { Left ($2, $3) }+          | colon Type eq StaticExpression { Right (Just $2, ConcreteType $4) } -- FIXME wrong wrong bad!!  MaybeAnnot : colon Sort { Just $2 }            | { Nothing }  AndStadef : stadef IdentifierOr SortArgs StaticDef { Stadef $2 $3 $4 }+          | stadef IdentifierOr lineComment SortArgs StaticDef { Stadef $2 $4 $5 }           | stadef Operator SortArgs StaticDef { Stadef $2 $3 $4 }           | AndStadef and IdentifierOr SortArgs StaticDef { AndD $1 (Stadef $3 $4 $5) }           | AndStadef and Operator SortArgs StaticDef { AndD $1 (Stadef $3 $4 $5) }@@ -871,8 +880,8 @@              | vbar Universals Sort of Sort { DataSortLeaf $2 $3 (Just $5) }              | DataSortLeaf Comment { $1 } -DataSortLeaves : DataSortLeaf { [$1] }-               | DataSortLeaves DataSortLeaf { $2 : $1 }+DataSortLeaves : DataSortLeaf { $1 :| [] }+               | DataSortLeaves DataSortLeaf { $2 :| toList $1 }  CommentContents : commentContents { Comment $1 }                 | CommentContents commentContents { over comment (<> $2) $1 }@@ -889,6 +898,10 @@ Load : staload { (True, $1) }      | dynload { (False, $1) } +MacroArgs : doubleParens { Just [] }+          | openParen IdentifiersIn closeParen { Just $2 }+          | { Nothing }+ -- | Parse a declaration Declaration : include string { Include $2 }             | define { Define $1 }@@ -898,10 +911,8 @@             | define identifierSpace intLit { Define ($1 ++ " " ++ to_string $2 ++ " " ++ show $3) }             | cblock { CBlock $1 }             | datasort identifierSpace eq DataSortLeaves { DataSort $1 (to_string $2) $4 }-            | macdef IdentifierOr doubleParens eq Expression { MacDecl $1 $2 [] $5 }-            | macdef customOperator doubleParens eq Expression { MacDecl $1 (to_string $2) [] $5 }-            | macdef IdentifierOr openParen IdentifiersIn closeParen eq Expression { MacDecl $1 $2 $4 $7 }-            | macdef customOperator openParen IdentifiersIn closeParen eq Expression { MacDecl $1 (to_string $2) $4 $7 }+            | macdef IdentifierOr MacroArgs eq Expression { MacDecl $1 $2 $3 $5 }+            | macdef customOperator MacroArgs eq Expression { MacDecl $1 (to_string $2) $3 $5 }             | lineComment { Comment (to_string $1) }             | Comment { $1 }             | Load underscore eq string { Load (fst $1) (get_staload $ snd $1) (Just "_") $4 }

@@ -14,7 +14,7 @@  import           Control.Composition          hiding ((&)) import           Data.Bool                    (bool)-import           Data.Foldable                (toList)+import           Data.Foldable                (fold, toList) import           Data.Functor.Foldable        (cata) import           Data.List                    (isPrefixOf) import           Data.List.NonEmpty           (NonEmpty (..))@@ -177,9 +177,9 @@         a (BoxTupleExF _ es)           = "'(" <> mconcat (punctuate ", " (toList $ NE.reverse es)) <> ")"         a (WhileF _ e e')              = "while" <> parens e <> e'         a (ForF _ e e')                = "for" <> parens e <> e'-        a (WhileStarF _ us t as e e' Nothing)   = "while*" <> prettyUsNil us <> prettyTermetric (Just t) <> prettyArgs as <+> "=>" <$> indent 4 e <$> indent 4 e'-        a (WhileStarF _ us t as e e' (Just ty)) = "while*" <> prettyUsNil us <> prettyTermetric (Just t) <> prettyArgs as <+> ":" <+> prettyArgs ty <+> "=>" <$> indent 4 e <$> indent 4 e'-        a (ForStarF _ us t as e e')    = "for*" <> prettyUsNil us <> prettyTermetric (Just t) <> prettyArgs as <+> "=>" <$> indent 4 e <$> indent 4 e'+        a (WhileStarF _ us t as e e' Nothing)   = "while*" <> prettyUsStarNil us <> prettyTermetric t <> prettyArgs as <+> "=>" <$> indent 4 e <$> indent 4 e'+        a (WhileStarF _ us t as e e' (Just ty)) = "while*" <> prettyUsStarNil us <> prettyTermetric t <> prettyArgs as <+> ":" <+> prettyArgs ty <+> "=>" <$> indent 4 e <$> indent 4 e'+        a (ForStarF _ us t as e e')    = "for*" <> prettyUsStarNil us <> prettyTermetric t <> prettyArgs as <+> "=>" <$> indent 4 e <$> indent 4 e'         a (ActionsF (ATS [d]))         = "{" <+> pretty d <+> "}"         a (ActionsF as)                = "{" <$> indent 2 (pretty as) <$> "}"         a UnderscoreLitF{}             = "_"@@ -195,7 +195,7 @@         a (MacroVarF _ s) = ",(" <> text s <> ")"         a BinListF{} = undefined -- Shouldn't happen -        prettyImplicits = mconcat . fmap (prettyArgsU "<" ">") . reverse+        prettyImplicits = fold . fmap (prettyArgsU "<" ">") . reverse          prettyIfCase []              = mempty         prettyIfCase [(s, l, t)]     = "|" <+> s <+> pretty l <+> t@@ -229,6 +229,7 @@         a (UniversalPatternF _ n us p) = text n <> prettyArgsU "" "" us <> p         a (ExistentialPatternF e p)    = pretty e <> p         a (AsF _ p p')                 = p <+> "as" <+> p'+        a (BinPatternF _ op p p')      = p <+> pretty op <+> p'  argHelper :: Eq a => (Doc -> Doc -> Doc) -> Arg a -> Doc argHelper _ (Arg (First s))   = pretty s@@ -260,6 +261,7 @@             | squish op = se <> pretty op <> se'             | otherwise = se <+> pretty op <+> se'         a (StaticIntF i)            = pretty i+        a (StaticHexF h)            = text h         a StaticVoidF{}             = "()"         a (SifF e e' e'')           = "sif" <+> e <+> "then" <$> indent 2 e' <$> "else" <$> indent 2 e''         a (SCallF n cs)             = pretty n <> parens (mconcat (punctuate "," . fmap pretty $ cs))@@ -269,6 +271,7 @@             ("let" <$> indent 2 (pretty e) <$> endLet e')             ("let" <+> pretty e <$> endLet e')         a (SCaseF ad e sls) = "case" <> pretty ad <+> e <+> "of" <$> indent 2 (prettyCases sls)+        a (SStringF s)      = text s  instance Eq a => Pretty (Sort a) where     pretty = cata a where@@ -298,9 +301,9 @@         a (FromVTF t)                      = t <> "?!"         a (MaybeValF t)                    = t <> "?"         a (AtExprF _ t t')                 = t <+> "@" <+> pretty t'-        a (AtTypeF _ t)                    = "@" <> t-        a (ProofTypeF _ t t')              = parens (pre' `op` "|" <+> t')-            where pre' = prettyArgsG mempty mempty (toList t)+        a (ArrayTypeF _ t n)               = "@[" <> t <> "][" <> pretty n <> "]"+        a (ProofTypeF _ t t')              = parens (pre' `op` "|" <+> prettyArgsG mempty mempty t')+            where pre' = prettyArgsG mempty mempty t                   op = bool (<+>) (<>) ('\n' `elem` showFast pre')         a (ConcreteTypeF e)                = pretty e         a (TupleF _ ts)                    = parens (mconcat (punctuate ", " (fmap pretty (reverse ts))))@@ -308,11 +311,11 @@         a (RefTypeF t)                     = "&" <> t         a (FunctionTypeF s t t')           = t <+> string s <+> t'         a (ViewLiteralF c)                 = "view" <> pretty c-        a NoneTypeF{}                      = "()"         a ImplicitTypeF{}                  = ".."         a (AnonymousRecordF _ rs)          = prettyRecord rs         a (ParenTypeF _ t)                 = parens t         a (WhereTypeF _ t i sa t')         = t <#> indent 2 ("where" </> pretty i <+> prettySortArgs sa <+> "=" <+> pretty t')+        a AddrTypeF{}                      = "addr"  gan :: Eq a => Maybe (Sort a) -> Doc gan (Just t) = " : " <> pretty t <> " "@@ -337,7 +340,7 @@     pretty (Universal bs ty es) = lbrace <+> mconcat (punctuate ", " (fmap pretty bs)) <> gan ty <> "|" <+> mconcat (punctuate "; " (fmap pretty es)) <+> rbrace  instance Eq a => Pretty (ATS a) where-    pretty (ATS xs) = concatSame (reverse xs)+    pretty (ATS xs) = concatSame xs  prettyOr :: (Pretty a, Eq a) => [[a]] -> Doc prettyOr [] = mempty@@ -405,10 +408,10 @@ showFast :: Doc -> String showFast d = displayS (renderCompact d) mempty -prettyRecord :: (Pretty a) => [(String, a)] -> Doc+prettyRecord :: (Pretty a) => NonEmpty (String, a) -> Doc prettyRecord es-    | any ((>40) . length . showFast . pretty) es = prettyRecordF True es-    | otherwise                                   = lineAlt (prettyRecordF True es) (prettyRecordS True es)+    | any ((>40) . length . showFast . pretty) es = prettyRecordF True (toList es)+    | otherwise                                   = lineAlt (prettyRecordF True (toList es)) (prettyRecordS True (toList es))  prettyRecordS :: (Pretty a) => Bool -> [(String, a)] -> Doc prettyRecordS _ []             = mempty@@ -428,6 +431,10 @@ prettyUsNil [] = space prettyUsNil us = space <> foldMap pretty us <> space +prettyUsStarNil :: Eq a => [Universal a] -> Doc+prettyUsStarNil [] = space+prettyUsStarNil us = space <> foldMap pretty us+ prettyOf :: (Pretty a) => Maybe a -> Doc prettyOf Nothing  = mempty prettyOf (Just x) = space <> "of" <+> pretty x@@ -470,32 +477,30 @@ prettyBody c1 c2 [d] = c1 <> d <> c2 prettyBody c1 c2 ds  = (c1 <>) . align . indent (-1) . cat . (<> pure c2) $ ds -prettyArgsG' :: Doc -> Doc -> Doc -> [Doc] -> Doc-prettyArgsG' c3 c1 c2 = prettyBody c1 c2 . prettyHelper c3 . reverse--prettyArgsList :: Doc -> Doc -> Doc -> [Doc] -> Doc-prettyArgsList c3 c1 c2 = prettyBody c1 c2 . va . prettyHelper c3+prettyArgsG' :: Foldable t => Doc -> Doc -> Doc -> t Doc -> Doc+prettyArgsG' c3 c1 c2 = prettyBody c1 c2 . prettyHelper c3 . reverse . toList -va :: [Doc] -> [Doc]-va = (& _tail.traverse %~ group)+prettyArgsList :: Foldable t => Doc -> Doc -> Doc -> t Doc -> Doc+prettyArgsList c3 c1 c2 = prettyBody c1 c2 . va . prettyHelper c3 . toList+    where va = (& _tail.traverse %~ group) -prettyArgsG :: Doc -> Doc -> [Doc] -> Doc+prettyArgsG :: Foldable t => Doc -> Doc -> t Doc -> Doc prettyArgsG = prettyArgsG' ", " -prettyArgsU :: (Pretty a) => Doc -> Doc -> [a] -> Doc+prettyArgsU :: (Pretty a, Foldable f, Functor f) => Doc -> Doc -> f a -> Doc prettyArgsU = prettyArgs' "," -prettyArgs' :: (Pretty a) => Doc -> Doc -> Doc -> [a] -> Doc+prettyArgs' :: (Pretty a, Functor f, Foldable f) => Doc -> Doc -> Doc -> f a -> Doc prettyArgs' = fmap pretty -.*** prettyArgsG' -prettyArgs :: (Pretty a) => [a] -> Doc+prettyArgs :: (Pretty a, Foldable f, Functor f) => f a -> Doc prettyArgs = prettyArgs' ", " "(" ")"  prettyArgsNil :: Eq a => Maybe [Arg a] -> Doc prettyArgsNil Nothing   = mempty prettyArgsNil (Just as) = prettyArgs' ", " "(" ")" as -fancyU :: Eq a => [Universal a] -> Doc+fancyU :: Pretty a => [a] -> Doc fancyU = foldMap pretty  (<#>) :: Doc -> Doc -> Doc@@ -512,25 +517,23 @@ prettySig :: (Pretty a) => Maybe String -> Maybe a -> Doc prettySig = prettySigG space space -prettyTermetric :: Pretty a => Maybe a -> Doc-prettyTermetric (Just t) = softline <> ".<" <> pretty t <> ">." <> softline-prettyTermetric Nothing  = mempty+prettyTermetric :: Pretty a => a -> Doc+prettyTermetric t = softline <> ".<" <> pretty t <> ">." <> softline +prettyMTermetric :: Pretty a => Maybe a -> Doc+prettyMTermetric = maybe mempty prettyTermetric+ -- FIXME figure out a nicer algorithm for when/how to split lines. instance Eq a => Pretty (PreFunction a) where     pretty (PreF i si [] [] as rt Nothing (Just e)) = pretty i <> prettyArgsNil as <> prettySig si rt <> "=" <$> indent 2 (pretty e)-    pretty (PreF i si [] us as rt t (Just e)) = pretty i </> fancyU us <> prettyTermetric t <> prettyArgsNil as <> prettySig si rt <> "=" <$> indent 2 (pretty e)+    pretty (PreF i si [] us as rt t (Just e)) = pretty i </> fancyU us <> prettyMTermetric t <> prettyArgsNil as <> prettySig si rt <> "=" <$> indent 2 (pretty e)     pretty (PreF i si pus [] as rt Nothing (Just e)) = fancyU pus </> pretty i <> prettyArgsNil as <> prettySig si rt <> "=" <$> indent 2 (pretty e)-    pretty (PreF i si pus us as rt t (Just e)) = fancyU pus </> pretty i </> fancyU us <> prettyTermetric t <> prettyArgsNil as <> prettySig si rt <> "=" <$> indent 2 (pretty e)+    pretty (PreF i si pus us as rt t (Just e)) = fancyU pus </> pretty i </> fancyU us <> prettyMTermetric t <> prettyArgsNil as <> prettySig si rt <> "=" <$> indent 2 (pretty e)     pretty (PreF i si [] [] as rt Nothing Nothing) = pretty i <> prettyArgsNil as <> prettySigNull si rt     pretty (PreF i si [] us Nothing rt Nothing Nothing) = pretty i </> fancyU us <> prettySigNull si rt     pretty (PreF i si [] us as rt Nothing Nothing) = pretty i </> fancyU us </> prettyArgsNil as <> prettySigNull si rt-    pretty (PreF i si pus [] as rt t Nothing) = fancyU pus </> pretty i <> prettyTermetric t </> prettyArgsNil as <> prettySigNull si rt-    pretty (PreF i si pus us as rt t Nothing) = fancyU pus </> pretty i <> prettyTermetric t </> fancyU us </> prettyArgsNil as <> prettySigNull si rt--instance Eq a => Pretty (DataPropLeaf a) where-    pretty (DataPropLeaf us e Nothing)   = "|" <+> foldMap pretty (reverse us) <+> pretty e-    pretty (DataPropLeaf us e (Just e')) = "|" <+> foldMap pretty (reverse us) <+> pretty e <+> "of" <+> pretty e'+    pretty (PreF i si pus [] as rt t Nothing) = fancyU pus </> pretty i <> prettyMTermetric t </> prettyArgsNil as <> prettySigNull si rt+    pretty (PreF i si pus us as rt t Nothing) = fancyU pus </> pretty i <> prettyMTermetric t </> fancyU us </> prettyArgsNil as <> prettySigNull si rt  prettyFix :: (Pretty a) => Either a String -> Doc prettyFix (Left i)  = pretty i@@ -551,8 +554,7 @@ valSig = prettySigG mempty mempty (Just mempty)  prettySortArgs :: (Pretty a) => Maybe [a] -> Doc-prettySortArgs Nothing   = mempty-prettySortArgs (Just as) = prettyArgs' ", " "(" ")" as+prettySortArgs = maybe mempty (prettyArgs' ", " "(" ")")  maybeT :: Pretty a => Maybe a -> Doc maybeT (Just x) = ":" <+> pretty x@@ -563,10 +565,10 @@     pretty (AbsType _ s as t)               = "abstype" <+> text s <> prettySortArgs as <> prettyMaybeType t     pretty (AbsViewType _ s as Nothing)     = "absvtype" <+> text s <> prettySortArgs as     pretty (AbsViewType _ s as (Just t))    = "absvtype" <+> text s <> prettySortArgs as <+> "=" <+> pretty t-    pretty (SumViewType s as ls)            = "datavtype" <+> text s <> prettySortArgs as <+> "=" <$> prettyLeaf ls-    pretty (DataView _ s as ls)             = "dataview" <+> text s <> prettySortArgs as <+> "=" <$> prettyLeaf ls-    pretty (SumType s as ls)                = "datatype" <+> text s <> prettySortArgs as <+> "=" <$> prettyLeaf ls-    pretty (DataSort _ s ls)                = "datasort" <+> text s <+> "=" <$> prettyDSL ls+    pretty (SumViewType s as ls)            = "datavtype" <+> text s <> prettySortArgs as <+> "=" <$> prettyLeaf (toList ls)+    pretty (DataView _ s as ls)             = "dataview" <+> text s <> prettySortArgs as <+> "=" <$> prettyLeaf (toList ls)+    pretty (SumType s as ls)                = "datatype" <+> text s <> prettySortArgs as <+> "=" <$> prettyLeaf (toList ls)+    pretty (DataSort _ s ls)                = "datasort" <+> text s <+> "=" <$> prettyDSL (toList ls)     pretty (Impl as i)                      = "implement" <+> prettyArgsNil as <> pretty i     pretty (ProofImpl as i)                 = "primplmnt" <+> prettyArgsNil as <> pretty i     pretty (PrVal p (Just e) Nothing)       = "prval" <+> pretty p <+> "=" <+> pretty e@@ -582,7 +584,7 @@     pretty (Var t p Nothing (Just e))       = "var" <+> pretty p <> valSig t <+> "with" <+> pretty e     pretty (Var t p (Just e) Nothing)       = "var" <+> pretty p <> valSig t <+> "=" <+> pretty e     pretty (Var t p Nothing Nothing)        = "var" <+> pretty p <> valSig t-    pretty (Var _ _ _ Just{})               = undefined+    pretty (Var _ _ _ Just{})               = undefined -- TODO figure out what this is supposed to be     pretty (Include s)                      = "#include" <+> pretty s     pretty (Load sta b Nothing s)           = bool "" "#" b <> bool "dyn" "sta" sta <> "load" <+> pretty s     pretty (Load sta b (Just q) s)          = bool "" "#" b <> bool "dyn" "sta" sta <> "load" <+> pretty q <+> "=" <+> pretty s@@ -616,13 +618,15 @@     pretty (Stacst _ n t (Just e))          = "stacst" </> pretty n <+> ":" </> pretty t <+> "=" </> pretty e     pretty (PropDef _ s as@Just{} t)        = "propdef" </> text s <+> prettyArgsNil as <+> "=" </> pretty t     pretty (PropDef _ s Nothing t)          = "propdef" </> text s <+> "=" </> pretty t-    pretty (Local _ (ATS ds) (ATS []))      = "local" <$> indent 2 (pretty (ATS $ reverse ds)) <$> "in end"+    pretty (Local _ (ATS ds) (ATS []))      = "local" <$> indent 2 (pretty (ATS ds)) <$> "in end"     pretty (Local _ d d')                   = "local" <$> indent 2 (pretty d) <$> "in" <$> indent 2 (pretty d') <$> "end"     pretty (FixityDecl f ss)                = pretty f <+> hsep (fmap text ss)     pretty (StaVal us i t)                  = "val" </> mconcat (fmap pretty us) <+> text i <+> ":" <+> pretty t-    pretty (Stadef i as (Right t))          = "stadef" <+> text i <+> prettySortArgs as <+> "=" <+> pretty t+    pretty (Stadef i as (Right (Nothing, t))) = "stadef" <+> text i <+> prettySortArgs as <+> "=" <+> pretty t+    pretty (Stadef i as (Right (Just ty, t))) = "stadef" <+> text i <+> prettySortArgs as <+> ":" <+> pretty ty <+> "=" <+> pretty t     pretty (Stadef i as (Left (se, mt)))    = "stadef" <+> text i <+> prettySortArgs as <+> "=" <+> pretty se <> maybeT mt-    pretty (AndD d (Stadef i as (Right t))) = pretty d <+> "and" <+> text i <+> prettySortArgs as <+> "=" <+> pretty t+    pretty (AndD d (Stadef i as (Right (Nothing, t)))) = pretty d <+> "and" <+> text i <+> prettySortArgs as <+> "=" <+> pretty t+    pretty (AndD d (Stadef i as (Right (Just ty, t)))) = pretty d <+> "and" <+> text i <+> prettySortArgs as <+> ":" <+> pretty ty <+> "=" <+> pretty t     pretty (AndD d (Stadef i as (Left (se, mt)))) = pretty d <+> "and" <+> text i <+> prettySortArgs as <+> "=" <+> pretty se <> maybeT mt     pretty (AbsView _ i as t)               = "absview" <+> text i <> prettySortArgs as <> prettyMaybeType t     pretty (AbsVT0p _ i as t)               = "absvt@ype" <+> text i <> prettySortArgs as <> prettyMaybeType t@@ -632,7 +636,8 @@     pretty (TKind _ n s)                    = pretty n <+> "=" <+> text s     pretty (SortDef _ s t)                  = "sortdef" <+> text s <+> "=" <+> either pretty pretty t     pretty (AndD d (SortDef _ i t))         = pretty d <+> "and" <+> text i <+> "=" <+> either pretty pretty t-    pretty (MacDecl _ n is e)               = "macdef" <+> text n <> "(" <> mconcat (punctuate ", " (fmap text is)) <> ") =" <+> pretty e+    pretty (MacDecl _ n (Just is) e)        = "macdef" <+> text n <> "(" <> mconcat (punctuate ", " (fmap text is)) <> ") =" <+> pretty e+    pretty (MacDecl _ n Nothing e)          = "macdef" <+> text n <+> "=" <+> pretty e     pretty (ExtVar _ s e)                   = "extvar" <+> text s <+> "=" <+> pretty e     pretty (AbsImpl _ n as e)               = "absimpl" </> pretty n <> prettySortArgs as <+> "=" </> pretty e     pretty AndD{}                           = undefined -- probably not valid syntax if we get to this point

@@ -90,12 +90,12 @@                    | AndDecl { andT :: Maybe (Type a), andPat :: Pattern a, _andExpr :: Expression a }                    | Include String                    | Load { static :: Bool, withOctothorpe :: Bool, qualName :: Maybe String, fileName :: String }-                   | Stadef String (SortArgs a) (Either (StaticExpression a, Maybe (Sort a)) (Type a))+                   | Stadef String (SortArgs a) (Either (StaticExpression a, Maybe (Sort a)) (Maybe (Type a), Type a))                    | CBlock String                    | TypeDef a String (SortArgs a) (Type a) (Maybe (Sort a))                    | ViewTypeDef a String (SortArgs a) (Type a)-                   | SumType { typeName :: String, typeArgs :: SortArgs a, _leaves :: [Leaf a] }-                   | SumViewType { typeName :: String, typeArgs :: SortArgs a, _leaves :: [Leaf a] }+                   | SumType { typeName :: String, typeArgs :: SortArgs a, _leaves :: NonEmpty (Leaf a) }+                   | SumViewType { typeName :: String, typeArgs :: SortArgs a, _leaves :: NonEmpty (Leaf a) }                    | AbsType a String (SortArgs a) (Maybe (Type a))                    | AbsViewType a String (SortArgs a) (Maybe (Type a))                    | AbsView a String (SortArgs a) (Maybe (Type a))@@ -106,7 +106,7 @@                    | OverloadIdent a String (Name a) (Maybe Int)                    | Comment { _comment :: String }                    | DataProp { pos :: a, propName :: String, propArgs :: SortArgs a, _propLeaves :: [DataPropLeaf a] }-                   | DataView a String (SortArgs a) [Leaf a]+                   | DataView a String (SortArgs a) (NonEmpty (Leaf a))                    | Extern a (Declaration a)                    | Define String                    | SortDef a String (Either (Sort a) (Universal a))@@ -119,8 +119,8 @@                    | Stacst a (Name a) (Type a) (Maybe (StaticExpression a))                    | PropDef a String (Args a) (Type a)                    | FixityDecl (Fixity a) [String]-                   | MacDecl a String [String] (Expression a)-                   | DataSort a String [DataSortLeaf a]+                   | MacDecl a String (Maybe [String]) (Expression a)+                   | DataSort a String (NonEmpty (DataSortLeaf a))                    | Exception String (Type a)                    | ExtVar a String (Expression a)                    | AbsImpl a (Name a) (SortArgs a) (Type a)@@ -144,18 +144,18 @@             | FromVT (Type a) -- | @a?!@             | MaybeVal (Type a) -- | @a?@             | AtExpr a (Type a) (StaticExpression a)-            | AtType a (Type a)-            | ProofType a (NonEmpty (Type a)) (Type a) -- Aka (prf | val)+            | ArrayType a (Type a) (StaticExpression a)+            | ProofType a (NonEmpty (Type a)) (NonEmpty (Type a)) -- Aka (prf | val)             | ConcreteType (StaticExpression a)             | RefType (Type a)             | ViewType a (Type a)             | FunctionType String (Type a) (Type a)-            | NoneType a             | ImplicitType a             | ViewLiteral Addendum-            | AnonymousRecord a [(String, Type a)]+            | AnonymousRecord a (NonEmpty (String, Type a))             | ParenType a (Type a)             | WhereType a (Type a) String (SortArgs a) (Type a)+            | AddrType a -- ^ @addr@             deriving (Show, Eq, Generic, NFData)  data TypeF a x = TupleF a [x]@@ -169,18 +169,18 @@                | FromVTF x                | MaybeValF x                | AtExprF a x (StaticExpression a)-               | AtTypeF a x-               | ProofTypeF a (NonEmpty x) x+               | ArrayTypeF a x (StaticExpression a)+               | ProofTypeF a (NonEmpty x) (NonEmpty x)                | ConcreteTypeF (StaticExpression a)                | RefTypeF x                | ViewTypeF a x                | FunctionTypeF String x x-               | NoneTypeF a                | ImplicitTypeF a                | ViewLiteralF Addendum-               | AnonymousRecordF a [(String, x)]+               | AnonymousRecordF a (NonEmpty (String, x))                | ParenTypeF a x                | WhereTypeF a x String (SortArgs a) x+               | AddrTypeF a                deriving (Functor)  type instance Base (Type a) = TypeF a@@ -197,18 +197,18 @@     project (FromVT ty)                = FromVTF ty     project (MaybeVal ty)              = MaybeValF ty     project (AtExpr l ty se)           = AtExprF l ty se-    project (AtType l ty)              = AtTypeF l ty+    project (ArrayType l ty n)         = ArrayTypeF l ty n     project (ProofType l tys ty')      = ProofTypeF l tys ty'     project (ConcreteType se)          = ConcreteTypeF se     project (RefType ty)               = RefTypeF ty     project (ViewType l ty)            = ViewTypeF l ty     project (FunctionType s ty ty')    = FunctionTypeF s ty ty'-    project (NoneType l)               = NoneTypeF l     project (ImplicitType l)           = ImplicitTypeF l     project (ViewLiteral a)            = ViewLiteralF a     project (AnonymousRecord l stys)   = AnonymousRecordF l stys     project (ParenType l ty)           = ParenTypeF l ty     project (WhereType l ty s sas ty') = WhereTypeF l ty s sas ty'+    project (AddrType l)               = AddrTypeF l  -- | A type for @=>@, @=\<cloref1>@, etc. data LambdaType a = Plain a@@ -239,6 +239,7 @@                | UniversalPattern a String [Universal a] (Pattern a)                | ExistentialPattern (Existential a) (Pattern a)                | As a (Pattern a) (Pattern a)+               | BinPattern a (BinOp a) (Pattern a) (Pattern a) -- ^ For use with e.g. @::@.                deriving (Show, Eq, Generic, NFData)  data PatternF a x = WildcardF a@@ -254,6 +255,7 @@                   | UniversalPatternF a String [Universal a] x                   | ExistentialPatternF (Existential a) x                   | AsF a x x+                  | BinPatternF a (BinOp a) x x                   deriving (Functor)  type instance Base (Pattern a) = PatternF a@@ -272,6 +274,7 @@     project (UniversalPattern x s us p) = UniversalPatternF x s us p     project (ExistentialPattern e x)    = ExistentialPatternF e x     project (As x p p')                 = AsF x p p'+    project (BinPattern a op p p')      = BinPatternF a op p p'  data Paired a b = Both a b                 | First a@@ -361,6 +364,7 @@ data StaticExpression a = StaticVal (Name a)                         | StaticBinary (BinOp a) (StaticExpression a) (StaticExpression a)                         | StaticInt Int+                        | StaticHex String                         | SPrecede (StaticExpression a) (StaticExpression a)                         | StaticVoid a                         | Sif { scond :: StaticExpression a, whenTrue :: StaticExpression a, selseExpr :: StaticExpression a } -- Static if (for proofs)@@ -368,11 +372,13 @@                         | SUnary (UnOp a) (StaticExpression a)                         | SLet a [Declaration a] (Maybe (StaticExpression a))                         | SCase Addendum (StaticExpression a) [(Pattern a, LambdaType a, StaticExpression a)]+                        | SString String -- ^ @ext#@                         deriving (Show, Eq, Generic, NFData)  data StaticExpressionF a x = StaticValF (Name a)                            | StaticBinaryF (BinOp a) x x                            | StaticIntF Int+                           | StaticHexF String                            | SPrecedeF x x                            | StaticVoidF a                            | SifF x x x@@ -380,6 +386,7 @@                            | SUnaryF (UnOp a) x                            | SLetF a [Declaration a] (Maybe x)                            | SCaseF Addendum x [(Pattern a, LambdaType a, x)]+                           | SStringF String                            deriving (Functor)  type instance Base (StaticExpression a) = StaticExpressionF a@@ -387,6 +394,7 @@ instance Recursive (StaticExpression a) where     project (StaticVal n)         = StaticValF n     project (StaticBinary b x x') = StaticBinaryF b x x'+    project (StaticHex h)         = StaticHexF h     project (StaticInt i)         = StaticIntF i     project (SPrecede x x')       = SPrecedeF x x'     project (StaticVoid x)        = StaticVoidF x@@ -395,6 +403,7 @@     project (SUnary u x)          = SUnaryF u x     project (SLet x ds e)         = SLetF x ds e     project (SCase a x ples)      = SCaseF a x ples+    project (SString s)           = SStringF s  -- | A (possibly effectful) expression. data Expression a = Let a (ATS a) (Maybe (Expression a))@@ -434,7 +443,7 @@                          , val   :: Expression a                          , _arms :: [(Pattern a, LambdaType a, Expression a)] -- ^ Each (('Pattern' a), ('Expression' a)) pair corresponds to a branch of the 'case' statement                          }-                  | RecordValue a [(String, Expression a)] (Maybe (Type a))+                  | RecordValue a (NonEmpty (String, Expression a)) (Maybe (Type a))                   | Precede (Expression a) (Expression a)                   | ProofExpr a (NonEmpty (Expression a)) (Expression a)                   | TypeSignature (Expression a) (Type a)@@ -479,7 +488,7 @@                      | UnaryF (UnOp a) x                      | IfCaseF a [(x, LambdaType a, x)]                      | CaseF a Addendum x [(Pattern a, LambdaType a, x)]-                     | RecordValueF a [(String, x)] (Maybe (Type a))+                     | RecordValueF a (NonEmpty (String, x)) (Maybe (Type a))                      | PrecedeF x x                      | ProofExprF a (NonEmpty x) x                      | TypeSignatureF x (Type a)

@@ -20,6 +20,7 @@                                , comment                                ) where +import           Data.List.NonEmpty (NonEmpty) import           Language.ATS.Types import           Lens.Micro @@ -83,7 +84,7 @@ propLeaves f (DataProp l n as pl) = DataProp l n as <$> f pl propLeaves _ x                    = pure x -leaves :: Traversal' (Declaration a) [Leaf a]+leaves :: Traversal' (Declaration a) (NonEmpty (Leaf a)) leaves f (SumType t as l)     = SumType t as <$> f l leaves f (SumViewType t as l) = SumViewType t as <$> f l leaves _ x                    = pure x

@@ -10,7 +10,9 @@ dataprop fib_p(int, int) =   | fib_p_bas0(0, 0) of ()   | fib_p_bas1(1, 1) of ()-  | {n:nat}{ r0, r1 : int } fib_p_ind2(n + 2, r0 + r1) of (fib_p(n, r0), fib_p(n + 1, r1))+  | {n:nat}{ r0, r1 : int } fib_p_ind2(n + 2, r0 + r1) of (fib_p( n+                                                                , r0+                                                                ), fib_p(n + 1, r1))  stacst fib_b : (int, int) -> bool @@ -21,12 +23,14 @@ praxi fib_b_bas1() : [fib_b(1,1)] unit_p  extern-praxi fib_b_ind2 {n:nat}{ r0, r1 : int }  : [fib_b(n,r0) && fib_b(n+1,r1) ->> fib_b(n+2,r0+r1)] unit_p+praxi fib_b_ind2 {n:nat}{ r0, r1 : int } :+  [fib_b(n,r0) && fib_b(n+1,r1) ->> fib_b(n+2,r0+r1)] unit_p  fun f_fib_p {n:nat}(n : int(n)) : [r:int] (fib_p(n, r) | int(r)) =   let-    fun loop { i : nat | i < n }{ r0, r1 : int }(pf0 : fib_p(i, r0), pf1 : fib_p(i+1, r1)-                                                | i : int(i), r0 : int(r0), r1 : int(r1)) :+    fun loop { i : nat | i < n }{ r0, r1 : int }( pf0 : fib_p(i, r0)+                                                 , pf1 : fib_p(i+1, r1)+                                                  | i : int(i), r0 : int(r0), r1 : int(r1)) :       [r:int] (fib_p(n, r) | int(r)) =       if i + 1 < n then         loop(pf1, fib_p_ind2(pf0, pf1) | i + 1, r1, r0 + r1)@@ -48,3 +52,4 @@   in     println!(i)   end+

@@ -17,11 +17,11 @@         }          val () = loop1(sz2i(s1_l))-    val () = while* {i:nat}  .<i>. (i : int(i)) =>+    val () = while* {i:nat} .<i>. (i : int(i)) =>         (i > 0)         (column[i] := i ; i := i - 1)     val () = while(i > 0)(column[i] := i ; i := i - 1)-    val () = for* { i : nat | i <= m }  .<i>. (i : int(i)) =>+    val () = for* { i : nat | i <= m } .<i>. (i : int(i)) =>         (i := sz2i(s1_l) ; i > 0 ; i := i - 1)         (column[i] := i)     

@@ -32,13 +32,13 @@         prvar pf1 = pf_arr                  //-        val () = while* { i : nat | i <= m }  .<m-i>. ( i : int(i)-                                                      , p : ptr(larr+i*sizeof(int))-                                                      , pf0 : array_v(int, larr, i)-                                                      , pf1 : array_v(int?, larr+i*sizeof(int), m-i)-                                                      ) : ( pf0 : array_v(int, larr, m)-                                                          , pf1 : array_v(int?, larr+i*sizeof(int), 0)-                                                          ) =>+        val () = while* { i : nat | i <= m } .<m-i>. ( i : int(i)+                                                     , p : ptr(larr+i*sizeof(int))+                                                     , pf0 : array_v(int, larr, i)+                                                     , pf1 : array_v(int?, larr+i*sizeof(int), m-i)+                                                     ) : ( pf0 : array_v(int, larr, m)+                                                         , pf1 : array_v(int?, larr+i*sizeof(int), 0)+                                                         ) =>             (i < sz2i(s1_l))             {               //

@@ -0,0 +1,276 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/arith_prf.atxt+** Time of generation: Thu Jan 11 11:00:02 2018+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: September, 2011 *)+(* ****** ****** *)++#if(0)+//+// It is available in [basic_dyn.sats]+//+dataprop+MUL_prop+(+  int, int, int+) = // MUL_prop+  | {n:int}+    MULbas (0, n, 0)+  | {m:nat}{n:int}{p:int}+    MULind (m+1, n, p+n) of MUL_prop (m, n, p)+  | {m:pos}{n:int}{p:int}+    MULneg (~(m), n, ~(p)) of MUL_prop (m, n, p)+//+propdef MUL = MUL_prop+//+#endif+(* ****** ****** *)+praxi mul_make : { m, n : int } () -<prf> MUL(m, n, m*n)++praxi mul_elim :+  { m, n : int } {p:int} MUL(m, n, p) -<prf> [p == m*n] void++(* ****** ****** *)+//+prfun mul_istot { m, n : int } () :<prf> [p:int] MUL(m, n, p)++//+prfun mul_isfun { m, n : int }{ p1, p2 : int } ( MUL(m,n,p1)+                                               , MUL(m,n,p2)+                                               ) :<prf> [p1 == p2] void++// endfun+prfun mul_isfun2 { m, n : int }{ p1, p2 : int } ( MUL(m,n,p1)+                                                , MUL(m,n,p2)+                                                ) :<prf> EQINT(p1, p2)++//+(* ****** ****** *)+//+// HX: (m+i)*n = m*n+i*n+//+praxi mul_add_const {i:int}{ m, n : int }{p:int} (pf : MUL(m, n, p)) +  :<prf> MUL(m+i, n, p+i*n)++// end of [mul_add_const]+//+(* ****** ****** *)+//+// HX: (ax+b)*(cy+d) = ac*xy + ad*x + bc*y + bd+//+praxi mul_expand_linear+{ a, b : int }{ c, d : int }{ x, y : int }{xy:int} (pf : MUL(x, y, xy)) +  :<prf> MUL(a*x+b, c*y+d, a*c*xy+a*d*x+b*c*y+b*d)++// end of [mul_expand_linear]+(* ****** ****** *)+//+// HX: (a1x1+a2x2+b)*(c1y1+c2y2+d) = ...+//+praxi mul_expand2_linear+{ a1, a2, b : int }{ c1, c2, d : int }{ x1, x2 : int }{ y1, y2 : int }{ x1y1, x1y2, x2y1, x2y2 : int }+(MUL(x1,y1,x1y1), MUL(x1,y2,x1y2), MUL(x2,y1,x2y1), MUL(x2,y2,x2y2)) +  :<prf>+  MUL_prop(a1*x1+a2*x2+b, c1*y1+c2*y2+d, a1*c1*x1y1+a1*c2*x1y2+a2*c1*x2y1+a2*c2*x2y2+a1*d*x1+a2*d*x2+b*c1*y1+b*c2*y2+b*d)++(* end of [mul_expand2_linear] *)+(* ****** ****** *)+//+prfun mul_gte_gte_gte :+  { m, n : int | m >= 0; n >= 0 } () -<prf> [m*n >= 0] void++prfun mul_lte_gte_lte :+  { m, n : int | m <= 0; n >= 0 } () -<prf> [m*n <= 0] void++prfun mul_gte_lte_lte :+  { m, n : int | m >= 0; n <= 0 } () -<prf> [m*n <= 0] void++prfun mul_lte_lte_gte :+  { m, n : int | m <= 0; n <= 0 } () -<prf> [m*n >= 0] void++//+(* ****** ****** *)+//+prfun mul_nat_nat_nat :+  { m, n : nat } {p:int} MUL(m, n, p) -<prf> [p >= 0] void++prfun mul_pos_pos_pos :+  { m, n : pos } {p:int} MUL(m, n, p) -<prf> [p >= m+n-1] void++//+(* ****** ****** *)+//+prfun mul_negate { m, n : int }{p:int} (pf : MUL(m, n, p)) :<prf>+  MUL(~m, n, ~p)++prfun mul_negate2 { m, n : int }{p:int} (pf : MUL(m, n, p)) :<prf>+  MUL(m, ~n, ~p)++//+(* ****** ****** *)+//+// HX: m*n = n*m+//+prfun mul_commute { m, n : int }{p:int} (pf : MUL(m, n, p)) :<prf>+  MUL(n, m, p)++prfun mul_is_commutative { m, n : int }{ p, q : int }+(pf1 : MUL(m, n, p), pf2 : MUL(n, m, q)) : [p == q] void++//+(* ****** ****** *)+//+// HX: m*(n1+n2) = m*n1+m*n2+//+prfun mul_distribute {m:int}{ n1, n2 : int }{ p1, p2 : int }+(pf1 : MUL(m, n1, p1), pf2 : MUL(m, n2, p2)) :<prf> MUL(m, n1+n2, p1+p2)++//+// HX: (m1+m2)*n = m1*n + m2*n+//+prfun mul_distribute2 { m1, m2 : int }{n:int}{ p1, p2 : int }+(pf1 : MUL(m1, n, p1), pf2 : MUL(m2, n, p2)) :<prf> MUL(m1+m2, n, p1+p2)++//+(* ****** ****** *)+prfun mul_is_associative+{ x, y, z : int }{ xy, yz : int }{ xy_z, x_yz : int }+( pf1 : MUL(x, y, xy)+, pf2 : MUL(y, z, yz)+, pf3 : MUL(xy, z, xy_z)+, pf4 : MUL(x, yz, x_yz)+) :<prf> [xy_z == x_yz] void++(* ****** ****** *)+//+praxi div_istot { x, y : int | x >= 0; y > 0 } () : DIV(x, y, x / y)++//+praxi divmod_istot { x, y : int | x >= 0; y > 0 } () :+  [ q, r : nat | r < y ] DIVMOD(x, y, q, r)++//+(* ****** ****** *)+praxi divmod_isfun+{ x, y : int | x >= 0; y > 0 }{ q1, q2 : int }{ r1, r2 : int }+(pf1 : DIVMOD(x, y, q1, r1), pf2 : DIVMOD(x, y, q2, r2)) :+  [q1 == q2; r1 == r2] void++// end of [divmod_isfun]+(* ****** ****** *)+praxi divmod_elim { x, y : int | x >= 0; y > 0 }{ q, r : int }+(pf : DIVMOD(x, y, q, r)) :+  [ qy : nat | 0 <= r; r < y; x == qy+r ] MUL(q, y, qy)++praxi divmod_mul_elim { x, y : int | x >= 0; y > 0 }{ q, r : int }+(pf : DIVMOD(x, y, q, r)) :+  [0 <= q; 0 <= r; r < y; q == ndiv_int_int(x,y); x == q*y+r] void++// end of [divmod_mul_elim]+(* ****** ****** *)+//+dataprop EXP2(int, int) =+  | EXP2bas((0, 1))+  | {n:nat}{p:nat} EXP2ind((n + 1, 2 * p)) of EXP2((n, p))++prfun lemma_exp2_param :+  {n:int} {p:int} EXP2(n, p) -<prf> [n >= 0; p >= 1] void++// end of [lemma_exp2_param]+//+prfun exp2_istot {n:nat} () : [p:nat] EXP2(n, p)++prfun exp2_isfun {n:nat}{ p1, p2 : int } ( pf1 : EXP2(n, p1)+                                         , pf2 : EXP2(n, p2)+                                         ) : [p1 == p2] void++// end of [exp2_isfun]+//+// HX: proven in [arith_prf.dats]+//+prfun exp2_ispos {n:nat}{p:int} (pf : EXP2(n, p)) : [p >= 1] void++// end of [exp2_ispos]+//+// HX: proven in [arith_prf.dats]+//+prfun exp2_is_mono { n1, n2 : nat | n1 <= n2 }{ p1, p2 : int }+(pf1 : EXP2(n1, p1), pf2 : EXP2(n2, p2)) : [p1 <= p2] void++// end of [exp2_is_mono]+//+// HX: proven in [arith_prf.dats]+//+prfun exp2_muladd { n1, n2 : nat | n1 <= n2 }{ p1, p2 : int }{p:int}+(pf1 : EXP2(n1, p1), pf2 : EXP2(n2, p2), pf3 : MUL(p1, p2, p)) :+  EXP2(n1+n2, p)++// end of [exp2_muladd]+//+(* ****** ****** *)+absprop EXP (int, int, int)++praxi lemma_exp_param {b:int}{n:int}{p:int} (pf : EXP(b, n, p)) :+  [n >= 0] void++// end of [lemma_exp_param]+praxi exp_istot {b:int}{n:nat} () : [p:nat] EXP(b, n, p)++praxi exp_isfun {b:int}{n:int}{ p1, p2 : int } ( pf1 : EXP(b, n, p1)+                                               , pf2 : EXP(b, n, p2)+                                               ) : [p1 == p2] void++// end of [exp_isfun]+praxi exp_elim_0 {n:pos}{p:int} (pf : EXP(0, n, p)) : [p == 0] void++praxi exp_elim_1 {n:int}{p:int} (pf : EXP(1, n, p)) : [p == 1] void++praxi exp_elim_2 {n:int}{p:int} (pf : EXP(2, n, p)) : EXP2(n, p)++praxi exp_elim_b_0 {b:int}{p:int} (pf : EXP(b, 0, p)) : [p == 1] void++praxi exp_elim_b_1 {b:int}{p:int} (pf : EXP(b, 1, p)) : [p == b] void++praxi exp_elim_b_2 {b:int}{p:int} (pf : EXP(b, 2, p)) : MUL(b, b, p)++praxi exp_muladd {b:int}{ n1, n2 : int }{ p1, p2 : int }{p:int}+(pf1 : EXP(b, n1, p1), pf2 : EXP(b, n2, p2)) : EXP(b, n1+n2, p1*p2)++// end of [exp_muladd]+praxi exp_expmul {b:int}{ n1, n2 : int }{bn1:int}{bn1n2:int}+(pf1 : EXP(b, n1, bn1), pf2 : EXP(bn1, n2, bn1n2)) :+  EXP(b, n1*n2, bn1n2)++// end of [exp_muladd]+(* ****** ****** *)+(* end of [arith_prf.sats] *)

@@ -0,0 +1,309 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)++(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/arith_prf.atxt+** Time of generation: Thu Jan 11 11:00:02 2018+*)++(* ****** ****** *)++(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: September, 2011 *)++(* ****** ****** *)++#if(0)+//+// It is available in [basic_dyn.sats]+//+dataprop+MUL_prop+(+  int, int, int+) = // MUL_prop+  | {n:int}+    MULbas (0, n, 0)+  | {m:nat}{n:int}{p:int}+    MULind (m+1, n, p+n) of MUL_prop (m, n, p)+  | {m:pos}{n:int}{p:int}+    MULneg (~(m), n, ~(p)) of MUL_prop (m, n, p)+//+propdef MUL = MUL_prop+//+#endif++(* ****** ****** *)++praxi+mul_make : {m,n:int} () -<prf> MUL (m, n, m*n)+praxi+mul_elim : {m,n:int} {p:int} MUL (m, n, p) -<prf> [p == m*n] void++(* ****** ****** *)+//+prfun+mul_istot{m,n:int}():<prf> [p:int] MUL(m, n, p)+//+prfun+mul_isfun+{m,n:int}{p1,p2:int}+(+  MUL(m, n, p1), MUL(m, n, p2)+) :<prf> [p1==p2] void // endfun+prfun+mul_isfun2{m,n:int}{p1,p2:int}+  (MUL(m, n, p1), MUL(m, n, p2)):<prf> EQINT(p1, p2)+//+(* ****** ****** *)+//+// HX: (m+i)*n = m*n+i*n+//+praxi+mul_add_const+  {i:int}{m,n:int}{p:int}+  (pf: MUL (m, n, p)):<prf> MUL(m+i, n, p+i*n)+// end of [mul_add_const]+//+(* ****** ****** *)+//+// HX: (ax+b)*(cy+d) = ac*xy + ad*x + bc*y + bd+//+praxi+mul_expand_linear // a,b,c,d: constants!+  {a,b:int}+  {c,d:int}+  {x,y:int}{xy:int}+(+  pf: MUL(x, y, xy)+) :<prf> MUL(a*x+b, c*y+d, a*c*xy+a*d*x+b*c*y+b*d)+// end of [mul_expand_linear]++(* ****** ****** *)+//+// HX: (a1x1+a2x2+b)*(c1y1+c2y2+d) = ...+//+praxi+mul_expand2_linear // a1,b1,c1,a2,b2,c2: constants!+  {a1,a2,b:int}+  {c1,c2,d:int}+  {x1,x2:int}{y1,y2:int}+  {x1y1,x1y2,x2y1,x2y2:int}+(+  MUL(x1, y1, x1y1), MUL(x1, y2, x1y2)+, MUL(x2, y1, x2y1), MUL(x2, y2, x2y2)+) :<prf>+MUL_prop (+  a1*x1+a2*x2+b+, c1*y1+c2*y2+d+, a1*c1*x1y1 + a1*c2*x1y2 ++  a2*c1*x2y1 + a2*c2*x2y2 ++  a1*d*x1 + a2*d*x2 + b*c1*y1 + b*c2*y2 + b*d+) (* end of [mul_expand2_linear] *)++(* ****** ****** *)+//+prfun+mul_gte_gte_gte+  : {m,n:int | m >= 0; n >= 0} () -<prf> [m*n >= 0] void+prfun+mul_lte_gte_lte+  : {m,n:int | m <= 0; n >= 0} () -<prf> [m*n <= 0] void+prfun+mul_gte_lte_lte+  : {m,n:int | m >= 0; n <= 0} () -<prf> [m*n <= 0] void+prfun+mul_lte_lte_gte+  : {m,n:int | m <= 0; n <= 0} () -<prf> [m*n >= 0] void+//+(* ****** ****** *)+//+prfun+mul_nat_nat_nat :+  {m,n:nat} {p:int} MUL(m, n, p) -<prf> [p >= 0] void+prfun+mul_pos_pos_pos :+  {m,n:pos} {p:int} MUL(m, n, p) -<prf> [p >= m+n-1] void+//+(* ****** ****** *)+//+prfun mul_negate+  {m,n:int}{p:int}(pf: MUL(m, n, p)):<prf> MUL(~m, n, ~p)+prfun mul_negate2+  {m,n:int}{p:int}(pf: MUL(m, n, p)):<prf> MUL(m, ~n, ~p)+//+(* ****** ****** *)+//+// HX: m*n = n*m+//+prfun mul_commute+  {m,n:int}{p:int}(pf: MUL(m, n, p)):<prf> MUL(n, m, p)+prfun mul_is_commutative+  {m,n:int}{p,q:int}(pf1: MUL(m, n, p), pf2: MUL(n, m, q)): [p==q] void+//+(* ****** ****** *)+//+// HX: m*(n1+n2) = m*n1+m*n2+//+prfun+mul_distribute+  {m:int}{n1,n2:int}{p1,p2:int}+  (pf1: MUL(m, n1, p1), pf2: MUL(m, n2, p2)):<prf> MUL(m, n1+n2, p1+p2)+//+// HX: (m1+m2)*n = m1*n + m2*n+//+prfun+mul_distribute2+  {m1,m2:int}{n:int}{p1,p2:int}+  (pf1: MUL(m1, n, p1), pf2: MUL(m2, n, p2)):<prf> MUL(m1+m2, n, p1+p2)+//+(* ****** ****** *)++prfun+mul_is_associative+  {x,y,z:int}+  {xy,yz:int}+  {xy_z,x_yz:int} (+  pf1: MUL (x, y, xy), pf2: MUL (y, z, yz)+, pf3: MUL (xy, z, xy_z), pf4: MUL (x, yz, x_yz)+) :<prf> [xy_z==x_yz] void++(* ****** ****** *)+//+praxi+div_istot+  {x,y:int | x >= 0; y > 0} (): DIV(x, y, x/y)+//+praxi+divmod_istot+{ x,y:int+| x >= 0; y > 0+} ((*void*)): [q,r:nat | r < y] DIVMOD(x, y, q, r)+//+(* ****** ****** *)++praxi+divmod_isfun+  {x,y:int | x >= 0; y > 0}+  {q1,q2:int} {r1,r2:int} (+  pf1: DIVMOD (x, y, q1, r1)+, pf2: DIVMOD (x, y, q2, r2)+) : [q1==q2;r1==r2] void // end of [divmod_isfun]++(* ****** ****** *)++praxi+divmod_elim+  {x,y:int | x >= 0; y > 0}+  {q,r:int}+(+  pf: DIVMOD (x, y, q, r)+) : [qy:nat | 0 <= r; r < y; x==qy+r] MUL (q, y, qy)++praxi+divmod_mul_elim+  {x,y:int | x >= 0; y > 0}+  {q,r:int}+  (pf: DIVMOD (x, y, q, r))+: [0 <= q; 0 <= r; r < y; q==ndiv_int_int(x, y); x==q*y+r] void+// end of [divmod_mul_elim]++(* ****** ****** *)+//+dataprop+EXP2 (int, int) =+  | EXP2bas (0, 1)+  | {n:nat}{p:nat}+    EXP2ind (n+1, 2*p) of EXP2 (n, p)+// end of [EXP2]+//+prfun lemma_exp2_param :+  {n:int}{p:int} EXP2 (n, p) -<prf> [n>=0;p>=1] void+// end of [lemma_exp2_param]+//+prfun exp2_istot {n:nat} (): [p:nat] EXP2 (n, p)+prfun exp2_isfun {n:nat} {p1,p2:int}+  (pf1: EXP2 (n, p1), pf2: EXP2 (n, p2)): [p1==p2] void+// end of [exp2_isfun]+//+// HX: proven in [arith_prf.dats]+//+prfun exp2_ispos+  {n:nat} {p:int} (pf: EXP2 (n, p)): [p >= 1] void+// end of [exp2_ispos]+//+// HX: proven in [arith_prf.dats]+//+prfun exp2_is_mono+  {n1,n2:nat | n1 <= n2} {p1,p2:int}+  (pf1: EXP2 (n1, p1), pf2: EXP2 (n2, p2)): [p1 <= p2] void+// end of [exp2_is_mono]+//+// HX: proven in [arith_prf.dats]+//+prfun exp2_muladd+  {n1,n2:nat | n1 <= n2} {p1,p2:int} {p:int} (+  pf1: EXP2 (n1, p1), pf2: EXP2 (n2, p2), pf3: MUL (p1, p2, p)+) : EXP2 (n1+n2, p) // end of [exp2_muladd]+//+(* ****** ****** *)++absprop EXP (int(*base*), int(*power*), int(*res*))++praxi lemma_exp_param+  {b:int}{n:int}{p:int} (pf: EXP (b, n, p)): [n >= 0] void+// end of [lemma_exp_param]++praxi exp_istot {b:int}{n:nat} (): [p:nat] EXP (b, n, p)+praxi exp_isfun {b:int}{n:int}{p1,p2:int}+  (pf1: EXP (b, n, p1), pf2: EXP (b, n, p2)): [p1==p2] void+// end of [exp_isfun]++praxi exp_elim_0 {n:pos}{p:int} (pf: EXP (0, n, p)): [p==0] void+praxi exp_elim_1 {n:int}{p:int} (pf: EXP (1, n, p)): [p==1] void+praxi exp_elim_2 {n:int}{p:int} (pf: EXP (2, n, p)): EXP2 (n, p)+praxi exp_elim_b_0 {b:int}{p:int} (pf: EXP (b, 0, p)): [p==1] void+praxi exp_elim_b_1 {b:int}{p:int} (pf: EXP (b, 1, p)): [p==b] void+praxi exp_elim_b_2 {b:int}{p:int} (pf: EXP (b, 2, p)): MUL (b, b, p)++praxi exp_muladd+  {b:int}{n1,n2:int}{p1,p2:int}{p:int} (+  pf1: EXP (b, n1, p1), pf2: EXP (b, n2, p2)+) : EXP (b, n1+n2, p1*p2) // end of [exp_muladd]++praxi exp_expmul+  {b:int}{n1,n2:int}{bn1:int}{bn1n2:int} (+  pf1: EXP (b, n1, bn1), pf2: EXP (bn1, n2, bn1n2)+) : EXP (b, n1*n2, bn1n2) // end of [exp_muladd]++(* ****** ****** *)++(* end of [arith_prf.sats] *)

@@ -0,0 +1,594 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2013 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/array.atxt+** Time of generation: Mon Jun  4 01:42:39 2018+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: Feburary, 2012 *)+(* ****** ****** *)+vtypedef RD(a: vt0p) = a++// for commenting: read-only+#define NSH (x) x // for commenting: no sharing+#define SHR (x) x // for commenting: it is shared++(* ****** ****** *)+sortdef t0p = t@ype++sortdef vtp = vtype++sortdef vt0p = vt@ype++(* ****** ****** *)+(*+//+// HX: [array_v] can also be defined as follows:+//+dataview+array_v+(+  a:vt@ype+, addr, int+) = // HX: for arry view+  | {l:addr}+    array_v_nil (a, l, 0)+  | {l:addr}{n:int}+    array_v_cons (a, l, n+1) of (a @ l, array_v (a, l+sizeof a, n))+// end of [array_v]+*)+(* ****** ****** *)+dataview arrayopt_v(a: vt@ype+, addr, int, bool) =+  | {l:addr}{n:int} arrayopt_v_some(a, l, n, true) of array_v(a, l, n)+  | {l:addr}{n:int} arrayopt_v_none(a, l, n, false) of array_v(a?, l, n)++// end of [arrayopt_v]+(* ****** ****** *)+//+exception ArraySubscriptExn of ()++//+(*+fun+ArraySubscriptExn():<> exn = "mac#%ArraySubscriptExn_make"+fun+isArraySubscriptExn(x: !exn):<> bool = "mac#%isArraySubscriptExn"+//+macdef+ifArraySubscriptExn+  {tres}(exn, body) =+(+let val x = ,(exn) in+(+//+if+isArraySubscriptExn(x)+then (+  let prval () = __vfree_exn (x) in ,(body) end+) else $raise (x)+//+) : tres // end of [if]+end (* end of [let] *)+) // end of [ifArraySubscriptExn]+*)+//+(* ****** ****** *)+//+praxi lemma_array_param {a:vt0p}{l:addr}{n:int} (A : &(@[INV(a)][n])) :+  [n >= 0] void++// end of [lemma_array_param]+//+praxi lemma_array_v_param {a:vt0p}{l:addr}{n:int}+(pf : !array_v(INV(a), l, n)) : [n >= 0] void++// end of [lemma_array_v_param]+//+(* ****** ****** *)+//+praxi array_v_nil : {a:vt0p} {l:addr} () -<prf> array_v(a, l, 0)++//+praxi array_v_unnil : {a:vt0p} {l:addr} array_v(a, l, 0) -<prf> void++//+prfun array_v_unnil_nil :+  { a1, a2 : vt0p } {l:addr} array_v(a1, l, 0) -<prf> array_v(a2, l, 0)++// end of [array_v_unnil_nil]+//+(* ****** ****** *)+//+praxi array_v_cons :+  {a:vt0p} {l:addr} {n:int} (a @ l, array_v(INV(a), l+sizeof(a), n)) -<prf> array_v(a, l, n+1)++//+praxi array_v_uncons :+  {a:vt0p} {l:addr} { n : int | n > 0 } array_v(INV(a), l, n) -<prf> (a @ l, array_v(a, l+sizeof(a), n-1))++(* ****** ****** *)+prfun array_v_sing {a:vt0p}{l:addr} (pf : INV(a) @ l) : array_v(a, l, 1)++prfun array_v_unsing {a:vt0p}{l:addr} (pf : array_v(INV(a), l, 1)) :+  a @ l++(* ****** ****** *)+//+fun {a:vt0p} array_getref_at {n:int} ( A : &RD(@[INV(a)][n])+                                     , i : sizeLt(n)+                                     ) :<> cPtr1(a)++//+(* ****** ****** *)+//+fun {a:t0p}{tk:tk} array_get_at_gint {n:int} ( A : &RD(@[INV(a)][n])+                                             , i : g1intLt(tk, n)+                                             ) :<> a++//+fun {a:t0p}{tk:tk} array_get_at_guint {n:int} ( A : &RD(@[INV(a)][n])+                                              , i : g1uintLt(tk, n)+                                              ) :<> a++//+overload [] with array_get_at_gint of 0++overload [] with array_get_at_guint of 0++//+symintr array_get_at++overload array_get_at with array_get_at_gint of 0++overload array_get_at with array_get_at_guint of 0++//+(* ****** ****** *)+//+fun {a:t0p}{tk:tk} array_set_at_gint {n:int} ( A : &(@[INV(a)][n])+                                             , i : g1intLt(tk, n)+                                             , x : a+                                             ) :<!wrt> void++//+fun {a:t0p}{tk:tk} array_set_at_guint {n:int} ( A : &(@[INV(a)][n])+                                              , i : g1uintLt(tk, n)+                                              , x : a+                                              ) :<!wrt> void++//+overload [] with array_set_at_gint of 0++overload [] with array_set_at_guint of 0++//+symintr array_set_at++overload array_set_at with array_set_at_gint of 0++overload array_set_at with array_set_at_guint of 0++//+(* ****** ****** *)+fun {a:vt0p}{tk:tk} array_exch_at_gint {n:int} ( A : &(@[INV(a)][n])+                                               , i : g1intLt(tk, n)+                                               , x : &a >> _+                                               ) :<!wrt> void++fun {a:vt0p}{tk:tk} array_exch_at_guint {n:int} ( A : &(@[INV(a)][n])+                                                , i : g1uintLt(tk, n)+                                                , x : &a >> _+                                                ) :<!wrt> void++symintr array_exch_at++overload array_exch_at with array_exch_at_gint of 0++overload array_exch_at with array_exch_at_guint of 0++(* ****** ****** *)+fun {a:vt0p} array_subreverse+{n:int}{ i, j : int | 0 <= i; i <= j; j <= n } ( A : &(@[INV(a)][n])+                                               , i : size_t(i)+                                               , j : size_t(j)+                                               ) :<!wrt> void++// end of [array_subreverse]+(* ****** ****** *)+fun {a:vt0p} array_interchange {n:int} ( A : &(@[INV(a)][n])+                                       , i : sizeLt(n)+                                       , j : sizeLt(n)+                                       ) :<!wrt> void++// end of [array_interchange]+(* ****** ****** *)+fun {a:vt0p} array_subcirculate {n:int} ( A : &(@[INV(a)][n])+                                        , i : sizeLt(n)+                                        , j : sizeLt(n)+                                        ) :<!wrt> void++// end of [array_subcirculate]+(* ****** ****** *)+fun {a:vt0p} array_ptr_takeout {l:addr}{n:int}{ i : nat | i < n }+(array_v(INV(a),l,n) | ptr(l), size_t(i)) : ( a @ l+i*sizeof(a)+                                            , a @ l+i*sizeof(a) -<lin,prf> array_v(a, l, n)+                                            | ptr(l+i*sizeof(a)))++(* end of [array_ptr_takeout] *)+(* ****** ****** *)+fun {a:vt0p} array_ptr_alloc {n:int} (asz : size_t(n)) :<!wrt>+  [l:agz] (array_v(a?, l, n), mfree_gc_v(l)| ptr(l))++(* end of [array_ptr_alloc] *)+fun array_ptr_free {a:vt0p}{l:addr}{n:int} ( array_v(a?, l, n)+                                           , mfree_gc_v(l)+                                            | ptr(l)) :<!wrt> void++// end-of-function+(* ****** ****** *)+//+fun fprint_array$sep(out : FILEref) : void++//+fun {a:vt0p} fprint_array_int {n:int} ( out : FILEref+                                      , A : &RD(@[INV(a)][n])+                                      , n : int(n)+                                      ) : void++// end of [fprint_array_int]+fun {a:vt0p} fprint_array_size {n:int} ( out : FILEref+                                       , A : &RD(@[INV(a)][n])+                                       , n : size_t(n)+                                       ) : void++// end of [fprint_array_size]+//+symintr fprint_array++overload fprint_array with fprint_array_int++overload fprint_array with fprint_array_size++//+fun {a:vt0p} fprint_array_sep {n:int} ( out : FILEref+                                      , A : &RD(@[INV(a)][n])+                                      , n : size_t(n)+                                      , sep : NSH(string)+                                      ) : void++// end of [fprint_array_sep]+//+(* ****** ****** *)+overload fprint with fprint_array++overload fprint with fprint_array_sep++(* ****** ****** *)+fun {a:vt0p} array_copy {n:int} ( to : &(@[a?][n]) >> @[a][n]+                                , from : &RD(@[INV(a)][n]) >> @[a?!][n]+                                , n : size_t(n)+                                ) :<!wrt> void++// end of [array_copy]+(* ****** ****** *)+//+fun {a:t0p} array_copy_from_list {n:int} ( A : &(@[a?][n]) >> @[a][n]+                                         , xs : list(INV(a), n)+                                         ) :<!wrt> void++// end of [array_copy_from_list]+//+fun {a:vt0p} array_copy_from_list_vt {n:int}+(A : &(@[a?][n]) >> @[a][n], xs : list_vt(INV(a), n)) :<!wrt> void++// end of [array_copy_from_list_vt]+//+(* ****** ****** *)+fun {a:vt0p} array_copy_to_list_vt {n:int}+(A : &RD(@[INV(a)][n]) >> @[a?!][n], n : size_t(n)) :<!wrt>+  list_vt(a, n)++// endfun+macdef array2list = array_copy_to_list_vt++(* ****** ****** *)+//+fun {a:vt0p} array_tabulate$fopr (i : size_t) : (a)++//+fun {a:vt0p} array_ptr_tabulate {n:int} (asz : size_t(n)) :+  [l:addr] (array_v(a, l, n), mfree_gc_v(l)| ptr(l))++// end of [arrayptr_tabulate]+//+(* ****** ****** *)+//+fun {a:vt0p} array_foreach {n:int} ( A : &(@[INV(a)][n]) >> @[a][n]+                                   , asz : size_t(n)+                                   ) : sizeLte(n)++// end of [array_foreach]+//+fun {a:vt0p}{env:vt0p} array_foreach_env {n:int}+(A : &(@[INV(a)][n]) >> @[a][n], asz : size_t(n), env : &(env) >> _) :+  sizeLte(n)++// end of [array_foreach_env]+//+fun {a:vt0p}{env:vt0p} array_foreach$cont (x : &a, env : &env) : bool++fun {a:vt0p}{env:vt0p} array_foreach$fwork ( x : &a >> _+                                           , env : &(env) >> _+                                           ) : void++//+(* ****** ****** *)+//+fun {a:vt0p} array_foreach_funenv {v:view}{vt:vtype}{n:int}{fe:eff}+(pf : !v+| A0 : &(@[INV(a)][n]) >> @[a][n], asz : size_t(n), f0 : (!v | &a >> _, !vt) -<fun,fe> void, env : !vt) +  :<fe> void++// end of [array_foreach_funenv]+//+fun array_foreach_funenv_tsz+{a:vt0p}{v:view}{vt:vtype}{n:int}{fe:eff}( pf : !v+                                         | A0 : &(@[INV(a)][n]) >> @[a][n]+                                         , asz : size_t(n)+                                         , tsz : sizeof_t(a)+                                         , f0 : (!v | &a >> _, !vt) -<fun,fe> void+                                         , env : !vt+                                         ) :<fe> void =+  "ext#%"++// end of [array_foreach_funenv_tsz]+//+(* ****** ****** *)+fun { a1, a2 : vt0p } array_foreach2 {n:int}+( A1 : &(@[INV(a1)][n]) >> @[a1][n]+, A2 : &(@[INV(a2)][n]) >> @[a2][n]+, asz : size_t(n)+) : sizeLte(n)++// end of [array_foreach2]+//+fun { a1, a2 : vt0p }{env:vt0p} array_foreach2_env {n:int}+( A1 : &(@[INV(a1)][n]) >> @[a1][n]+, A2 : &(@[INV(a2)][n]) >> @[a2][n]+, asz : size_t(n)+, env : &(env) >> env+) : sizeLte(n)++// end of [array_foreach2_env]+//+fun { a1, a2 : vt0p }{env:vt0p} array_foreach2$cont ( x1 : &a1+                                                    , x2 : &a2+                                                    , env : &env+                                                    ) : bool++fun { a1, a2 : vt0p }{env:vt0p} array_foreach2$fwork ( x1 : &a1 >> _+                                                     , x2 : &a2 >> _+                                                     , env : &(env) >> _+                                                     ) : void++//+(* ****** ****** *)+fun {a:vt0p} array_iforeach {n:int} ( A0 : &(@[INV(a)][n]) >> @[a][n]+                                    , asz : size_t(n)+                                    ) : sizeLte(n)++// end of [array_iforeach]+//+fun {a:vt0p}{env:vt0p} array_iforeach_env {n:int}+(A0 : &(@[INV(a)][n]) >> @[a][n], asz : size_t(n), env : &(env) >> _) :+  sizeLte(n)++// end of [array_iforeach_env]+//+fun {a:vt0p}{env:vt0p} array_iforeach$cont ( i : size_t+                                           , x : &a+                                           , env : &env+                                           ) : bool++fun {a:vt0p}{env:vt0p} array_iforeach$fwork ( i : size_t+                                            , x : &(a) >> _+                                            , env : &(env) >> _+                                            ) : void++//+(* ****** ****** *)+fun {a:vt0p} array_rforeach {n:int} ( A : &(@[INV(a)][n]) >> @[a][n]+                                    , asz : size_t(n)+                                    ) : sizeLte(n)++// end of [array_rforeach]+//+fun {a:vt0p}{env:vt0p} array_rforeach_env {n:int}+(A0 : &(@[INV(a)][n]) >> @[a][n], asz : size_t(n), env : &(env) >> _) :+  sizeLte(n)++// end of [array_rforeach_env]+//+fun {a:vt0p}{env:vt0p} array_rforeach$cont (x : &a, env : &env) : bool++fun {a:vt0p}{env:vt0p} array_rforeach$fwork ( x : &a >> _+                                            , env : &(env) >> _+                                            ) : void++//+(* ****** ****** *)+//+fun {a:vt0p} array_initize {n:int} ( A : &(@[a?][n]) >> @[a][n]+                                   , asz : size_t(n)+                                   ) : void++// end of [array_initize]+//+fun {a:vt0p} array_initize$init (i : size_t, x : &a? >> a) : void++//+(* ****** ****** *)+fun {a:t0p} array_initize_elt {n:int} ( A : &(@[a?][n]) >> @[a][n]+                                      , asz : size_t(n)+                                      , elt : (a)+                                      ) :<!wrt> void++// end of [array_initize_elt]+(* ****** ****** *)+fun {a:t0p} array_initize_list {n:int} ( A : &(@[a?][n]) >> @[a][n]+                                       , asz : int(n)+                                       , xs : list(INV(a), n)+                                       ) :<!wrt> void++// end of [array_initize_list]+fun {a:t0p} array_initize_rlist {n:int} ( A : &(@[a?][n]) >> @[a][n]+                                        , asz : int(n)+                                        , xs : list(INV(a), n)+                                        ) :<!wrt> void++// end of [array_initize_rlist]+(* ****** ****** *)+fun {a:vt0p} array_initize_list_vt {n:int} ( A : &(@[a?][n]) >> @[a][n]+                                           , asz : int(n)+                                           , xs : list_vt(INV(a), n)+                                           ) :<!wrt> void++// end of [array_initize_list_vt]+fun {a:vt0p} array_initize_rlist_vt {n:int} ( A : &(@[a?][n]) >> @[a][n]+                                            , asz : int(n)+                                            , xs : list_vt(INV(a), n)+                                            ) :<!wrt> void++// end of [array_initize_rlist_vt]+(* ****** ****** *)+//+fun {a:vt0p} array_uninitize {n:int} ( A0 : &(@[INV(a)][n]) >> @[a?][n]+                                     , asz : size_t(n)+                                     ) : void++// end of [array_uninitize]+//+fun {a:vt0p} array_uninitize$clear (i : size_t, x : &a >> a?) : void++//+(* ****** ****** *)+//+fun {a:vt0p} array_bsearch$ford (x : &RD(a)) :<> int++//+fun {a:vt0p} array_bsearch {n:int} (A : &RD(@[a][n]), n : size_t(n)) :<>+  sizeLte(n)++//+fun {a:vt0p} array_bsearch_fun {n:int} ( A0 : &RD(@[a][n])+                                       , asz : size_t(n)+                                       , key : &RD(a)+                                       , cmp : cmpref(a)+                                       ) :<> sizeLte(n)++// end of [array_bsearch_fun]+//+(* ****** ****** *)+//+(*+** HX: this one is based on [bsearch] in [stdlib]+*)+fun {a:vt0p} array_bsearch_stdlib {n:int} ( A0 : &RD(@[a][n])+                                          , asz : size_t(n)+                                          , key : &RD(a)+                                          , cmp : cmpref(a)+                                          ) :<> Ptr0++(* found/~found : ~null/null *)+//+(* ****** ****** *)+//+fun {a:vt0p} array_quicksort {n:int} ( A : &(@[INV(a)][n]) >> @[a][n]+                                     , n : size_t(n)+                                     ) :<!wrt> void++// end-of-function+fun {a:vt0p} array_quicksort$cmp (x1 : &RD(a), x2 : &RD(a)) :<> int++(*sgn*)+//+(* ****** ****** *)+(*+** HX: this one is based on [qsort] in [stdlib]+*)+fun {a:vt0p} array_quicksort_stdlib {n:int}+(A : &(@[INV(a)][n]) >> @[a][n], n : size_t(n), cmp : cmpref(a)) :<!wrt>+  void++// end of [array_quicksort_stdlib]+(* ****** ****** *)+//+fun {a:vt0p}{b:vt0p} array_mapto {n:int} ( A : &array(INV(a), n)+                                         , B : &array(b?, n) >> array(b, n)+                                         , n : size_t(n)+                                         ) : void++// end of [array_mapto]+//+fun {a:vt0p}{b:vt0p} array_mapto$fwork (x : &a, y : &b? >> b) : void++//+(* ****** ****** *)+//+fun { a, b : vt0p }{c:vt0p} array_map2to {n:int} ( A : &array(INV(a), n)+                                                 , B : &array(INV(b), n)+                                                 , C : &array(c?, n) >> array(c, n)+                                                 , n : size_t(n)+                                                 ) : void++// end of [array_map2to]+//+fun { a, b : vt0p }{c:vt0p} array_map2to$fwork ( x : &a+                                               , y : &b+                                               , z : &c? >> c+                                               ) : void++//+(* ****** ****** *)+//+(*+HX-2016:+Fisher–Yates shuffle+*)+//+fun {a:vt0p} array_permute {n:int} ( A : &(@[INV(a)][n]) >> @[a][n]+                                   , n : size_t(n)+                                   ) : void++//+fun array_permute$randint { n : int | n > 0 } (size_t(n)) : sizeLt(n)++//+(* ****** ****** *)+(* end of [array.sats] *)

@@ -0,0 +1,684 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2013 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)++(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/array.atxt+** Time of generation: Mon Jun  4 01:42:39 2018+*)++(* ****** ****** *)++(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: Feburary, 2012 *)++(* ****** ****** *)++vtypedef+RD(a:vt0p) = a // for commenting: read-only+#define NSH (x) x // for commenting: no sharing+#define SHR (x) x // for commenting: it is shared++(* ****** ****** *)++sortdef t0p = t@ype+sortdef vtp = viewtype+sortdef vt0p = viewt@ype++(* ****** ****** *)++(*+//+// HX: [array_v] can also be defined as follows:+//+dataview+array_v+(+  a:vt@ype+, addr, int+) = // HX: for arry view+  | {l:addr}+    array_v_nil (a, l, 0)+  | {l:addr}{n:int}+    array_v_cons (a, l, n+1) of (a @ l, array_v (a, l+sizeof a, n))+// end of [array_v]+*)++(* ****** ****** *)++dataview+arrayopt_v+(+  a:vt@ype+, addr, int, bool+) = // HX: for optional array view+  | {l:addr}{n:int}+    arrayopt_v_some (a, l, n, true) of array_v (a, l, n)+  | {l:addr}{n:int}+    arrayopt_v_none (a, l, n, false) of array_v (a?, l, n)+// end of [arrayopt_v]++(* ****** ****** *)+//+exception+ArraySubscriptExn of ()+//+(*+fun+ArraySubscriptExn():<> exn = "mac#%ArraySubscriptExn_make"+fun+isArraySubscriptExn(x: !exn):<> bool = "mac#%isArraySubscriptExn"+//+macdef+ifArraySubscriptExn+  {tres}(exn, body) =+(+let val x = ,(exn) in+(+//+if+isArraySubscriptExn(x)+then (+  let prval () = __vfree_exn (x) in ,(body) end+) else $raise (x)+//+) : tres // end of [if]+end (* end of [let] *)+) // end of [ifArraySubscriptExn]+*)+//+(* ****** ****** *)+//+praxi+lemma_array_param+  {a:vt0p}{l:addr}{n:int}+  (A: &(@[INV(a)][n])): [n >= 0] void+// end of [lemma_array_param]+//+praxi+lemma_array_v_param+  {a:vt0p}{l:addr}{n:int}+  (pf: !array_v (INV(a), l, n)): [n >= 0] void+// end of [lemma_array_v_param]+//+(* ****** ****** *)+//+praxi+array_v_nil :+  {a:vt0p}{l:addr} () -<prf> array_v (a, l, 0)+//+praxi+array_v_unnil :+  {a:vt0p}{l:addr} array_v (a, l, 0) -<prf> void+//+prfun+array_v_unnil_nil :+  {a1,a2:vt0p}{l:addr} array_v (a1, l, 0) -<prf> array_v (a2, l, 0)+// end of [array_v_unnil_nil]+//+(* ****** ****** *)+//+praxi+array_v_cons :+{a:vt0p}{l:addr}{n:int}+(a @ l, array_v (INV(a), l+sizeof(a), n)) -<prf> array_v (a, l, n+1)+//+praxi+array_v_uncons :+{a:vt0p}{l:addr}{n:int | n > 0}+array_v (INV(a), l, n) -<prf> (a @ l, array_v (a, l+sizeof(a), n-1))+//+(* ****** ****** *)++prfun+array_v_sing+  {a:vt0p}{l:addr} (pf: INV(a) @ l): array_v (a, l, 1)+prfun+array_v_unsing+  {a:vt0p}{l:addr} (pf: array_v (INV(a), l, 1)): a @ l++(* ****** ****** *)+//+fun+{a:vt0p}+array_getref_at+  {n:int} (A: &RD(@[INV(a)][n]), i: sizeLt n):<> cPtr1(a)+//+(* ****** ****** *)+//+fun{+a:t0p}{tk:tk+} array_get_at_gint+  {n:int}+  (A: &RD(@[INV(a)][n]), i: g1intLt(tk, n)):<> a+//+fun{+a:t0p}{tk:tk+} array_get_at_guint+  {n:int}+  (A: &RD(@[INV(a)][n]), i: g1uintLt(tk, n)):<> a+//+overload [] with array_get_at_gint of 0+overload [] with array_get_at_guint of 0+//+symintr array_get_at+overload array_get_at with array_get_at_gint of 0+overload array_get_at with array_get_at_guint of 0+//+(* ****** ****** *)+//+fun{+a:t0p}{tk:tk+} array_set_at_gint+  {n:int}+  (A: &(@[INV(a)][n]), i: g1intLt(tk, n), x: a):<!wrt> void+//+fun{+a:t0p}{tk:tk+} array_set_at_guint+  {n:int}+  (A: &(@[INV(a)][n]), i: g1uintLt(tk, n), x: a):<!wrt> void+//+overload [] with array_set_at_gint of 0+overload [] with array_set_at_guint of 0+//+symintr array_set_at+overload array_set_at with array_set_at_gint of 0+overload array_set_at with array_set_at_guint of 0+//+(* ****** ****** *)++fun{+a:vt0p}{tk:tk+} array_exch_at_gint{n:int}+(+  A: &(@[INV(a)][n]), i: g1intLt (tk, n), x: &a >> _+) :<!wrt> void+fun{+a:vt0p}{tk:tk+} array_exch_at_guint{n:int}+(+  A: &(@[INV(a)][n]), i: g1uintLt (tk, n), x: &a >> _+) :<!wrt> void++symintr array_exch_at+overload array_exch_at with array_exch_at_gint of 0+overload array_exch_at with array_exch_at_guint of 0++(* ****** ****** *)++fun+{a:vt0p}+array_subreverse+ {n:int}+ {i,j:int |+  0 <= i; i <= j; j <= n}+(+  A: &(@[INV(a)][n]), i: size_t(i), j: size_t(j)+) :<!wrt> void // end of [array_subreverse]++(* ****** ****** *)++fun+{a:vt0p}+array_interchange+  {n:int}+(+  A: &(@[INV(a)][n]), i: sizeLt (n), j: sizeLt (n)+) :<!wrt> void // end of [array_interchange]++(* ****** ****** *)++fun+{a:vt0p}+array_subcirculate+  {n:int}+(+  A: &(@[INV(a)][n]), i: sizeLt (n), j: sizeLt (n)+) :<!wrt> void // end of [array_subcirculate]++(* ****** ****** *)++fun+{a:vt0p}+array_ptr_takeout+  {l:addr}{n:int}{i:nat | i < n}+(+  array_v (INV(a), l, n) | ptr l, size_t i+) : (+  a @ (l+i*sizeof(a))+, a @ (l+i*sizeof(a)) -<lin,prf> array_v (a, l, n)+| ptr (l+i*sizeof(a))+) (* end of [array_ptr_takeout] *)++(* ****** ****** *)++fun+{a:vt0p}+array_ptr_alloc+  {n:int}+(+  asz: size_t n+) :<!wrt> [l:agz]+(+  array_v (a?, l, n), mfree_gc_v (l) | ptr l+) (* end of [array_ptr_alloc] *)++fun+{(*void*)}+array_ptr_free+  {a:vt0p}{l:addr}{n:int}+(+  array_v (a?, l, n), mfree_gc_v (l) | ptr l+) :<!wrt> void // end-of-function++(* ****** ****** *)+//+fun+{(*void*)}+fprint_array$sep (out: FILEref): void+//+fun{a:vt0p}+fprint_array_int{n:int}+(+  out: FILEref, A: &RD(@[INV(a)][n]), n: int(n)+) : void // end of [fprint_array_int]+fun{a:vt0p}+fprint_array_size{n:int}+(+  out: FILEref, A: &RD(@[INV(a)][n]), n: size_t(n)+) : void // end of [fprint_array_size]+//+symintr fprint_array+overload fprint_array with fprint_array_int+overload fprint_array with fprint_array_size+//+fun+{a:vt0p}+fprint_array_sep{n:int}+(+  out: FILEref+, A: &RD(@[INV(a)][n]), n: size_t n, sep: NSH(string)+) : void // end of [fprint_array_sep]+//+(* ****** ****** *)++overload fprint with fprint_array+overload fprint with fprint_array_sep++(* ****** ****** *)++fun+{a:vt0p}+array_copy{n:int}+(+  to: &(@[a?][n]) >> @[a][n]+, from: &RD(@[INV(a)][n]) >> @[a?!][n]+, n: size_t (n)+) :<!wrt> void // end of [array_copy]++(* ****** ****** *)+//+fun+{a:t0p}+array_copy_from_list{n:int}+(+  A: &(@[a?][n]) >> @[a][n], xs: list (INV(a), n)+) :<!wrt> void // end of [array_copy_from_list]+//+fun+{a:vt0p}+array_copy_from_list_vt{n:int}+(+  A: &(@[a?][n]) >> @[a][n], xs: list_vt (INV(a), n)+) :<!wrt> void // end of [array_copy_from_list_vt]+//+(* ****** ****** *)++fun+{a:vt0p}+array_copy_to_list_vt{n:int}+(+  A: &RD(@[INV(a)][n]) >> @[a?!][n], n: size_t n+) :<!wrt> list_vt (a, n) // endfun++macdef array2list = array_copy_to_list_vt++(* ****** ****** *)+//+fun+{a:vt0p}+array_tabulate$fopr(i: size_t): (a)+//+fun+{a:vt0p}+array_ptr_tabulate+  {n:int}+(+  asz: size_t(n)+) : [l:addr] (array_v(a, l, n), mfree_gc_v(l) | ptr(l))+// end of [arrayptr_tabulate]+//+(* ****** ****** *)+//+fun{+a:vt0p+} array_foreach{n:int}+(+  A: &(@[INV(a)][n]) >> @[a][n], asz: size_t(n)+) : sizeLte(n) // end of [array_foreach]+//+fun{+a:vt0p}{env:vt0p+} array_foreach_env{n:int}+(+  A: &(@[INV(a)][n]) >> @[a][n], asz: size_t(n), env: &(env) >> _+) : sizeLte(n) // end of [array_foreach_env]+//+fun{+a:vt0p}{env:vt0p+} array_foreach$cont (x: &a, env: &env): bool+fun{+a:vt0p}{env:vt0p+} array_foreach$fwork (x: &a >> _, env: &(env) >> _): void+//+(* ****** ****** *)+//+fun+{a:vt0p}+array_foreach_funenv+  {v:view}+  {vt:vtype}+  {n:int}+  {fe:eff}+(+  pf: !v+| A0: &(@[INV(a)][n]) >> @[a][n], asz: size_t(n)+, f0: (!v | &a >> _, !vt) -<fun,fe> void, env: !vt+) :<fe> void+// end of [array_foreach_funenv]+//+fun+array_foreach_funenv_tsz+  {a:vt0p}+  {v:view}+  {vt:vtype}+  {n:int}+  {fe:eff}+(+  pf: !v+| A0: &(@[INV(a)][n]) >> @[a][n]+, asz: size_t(n), tsz: sizeof_t(a)+, f0: (!v | &a >> _, !vt) -<fun,fe> void, env: !vt+) :<fe> void = "ext#%"+// end of [array_foreach_funenv_tsz]+//+(* ****** ****** *)++fun{+a1,a2:vt0p+} array_foreach2+  {n:int}+(+  A1: &(@[INV(a1)][n]) >> @[a1][n]+, A2: &(@[INV(a2)][n]) >> @[a2][n]+, asz: size_t (n)+) : sizeLte(n) // end of [array_foreach2]+//+fun{+a1,a2:vt0p}{env:vt0p+} array_foreach2_env+  {n:int}+(+  A1: &(@[INV(a1)][n]) >> @[a1][n]+, A2: &(@[INV(a2)][n]) >> @[a2][n]+, asz:size_t (n)+, env: &(env) >> env+) : sizeLte(n) // end of [array_foreach2_env]+//+fun{+a1,a2:vt0p}{env:vt0p+} array_foreach2$cont+  (x1: &a1, x2: &a2, env: &env): bool+fun{+a1,a2:vt0p}{env:vt0p+} array_foreach2$fwork+  (x1: &a1 >> _, x2: &a2 >> _, env: &(env) >> _): void+//+(* ****** ****** *)++fun+{a:vt0p}+array_iforeach+  {n:int}+(+A0: &(@[INV(a)][n]) >> @[a][n], asz: size_t(n)+) : sizeLte(n) // end of [array_iforeach]+//+fun{+a:vt0p}{env:vt0p+} array_iforeach_env+  {n:int}+(+A0: &(@[INV(a)][n]) >> @[a][n], asz: size_t(n), env: &(env) >> _+) : sizeLte(n) // end of [array_iforeach_env]+//+fun{+a:vt0p}{env:vt0p+} array_iforeach$cont(i: size_t, x: &a, env: &env): bool+fun{+a:vt0p}{env:vt0p+} array_iforeach$fwork(i: size_t, x: &(a) >> _, env: &(env) >> _): void+//+(* ****** ****** *)++fun+{a:vt0p}+array_rforeach{n:int}+(+  A: &(@[INV(a)][n]) >> @[a][n], asz: size_t(n)+) : sizeLte(n) // end of [array_rforeach]+//+fun{+a:vt0p}{env:vt0p+} array_rforeach_env{n:int}+(+A0: &(@[INV(a)][n]) >> @[a][n], asz: size_t(n), env: &(env) >> _+) : sizeLte(n) // end of [array_rforeach_env]+//+fun{+a:vt0p}{env:vt0p+} array_rforeach$cont(x: &a, env: &env): bool+fun{+a:vt0p}{env:vt0p+} array_rforeach$fwork(x: &a >> _, env: &(env) >> _): void+//+(* ****** ****** *)+//+fun{a:vt0p}+array_initize{n:int}+(+  A: &(@[a?][n]) >> @[a][n], asz: size_t(n)+) : void // end of [array_initize]+//+fun{a:vt0p}+array_initize$init (i: size_t, x: &a? >> a): void+//+(* ****** ****** *)++fun{a:t0p}+array_initize_elt{n:int}+(+  A: &(@[a?][n]) >> @[a][n], asz: size_t n, elt: (a)+) :<!wrt> void // end of [array_initize_elt]++(* ****** ****** *)++fun{a:t0p}+array_initize_list{n:int}+(+  A: &(@[a?][n]) >> @[a][n], asz: int n, xs: list(INV(a), n)+) :<!wrt> void // end of [array_initize_list]+fun{a:t0p}+array_initize_rlist{n:int}+(+  A: &(@[a?][n]) >> @[a][n], asz: int n, xs: list(INV(a), n)+) :<!wrt> void // end of [array_initize_rlist]++(* ****** ****** *)++fun{a:vt0p}+array_initize_list_vt{n:int}+(+  A: &(@[a?][n]) >> @[a][n], asz: int n, xs: list_vt(INV(a), n)+) :<!wrt> void // end of [array_initize_list_vt]+fun{a:vt0p}+array_initize_rlist_vt{n:int}+(+  A: &(@[a?][n]) >> @[a][n], asz: int n, xs: list_vt(INV(a), n)+) :<!wrt> void // end of [array_initize_rlist_vt]++(* ****** ****** *)+//+fun+{a:vt0p}+array_uninitize+  {n:int}+(+A0: &(@[INV(a)][n]) >> @[a?][n], asz: size_t(n)+) : void // end of [array_uninitize]+//+fun{a:vt0p}+array_uninitize$clear(i: size_t, x: &a >> a?): void+//+(* ****** ****** *)+//+fun{a:vt0p}+array_bsearch$ford (x: &RD(a)):<> int+//+fun+{a:vt0p}+array_bsearch+  {n:int}+  (A: &RD(@[a][n]), n: size_t(n)):<> sizeLte(n)+//+fun+{a:vt0p}+array_bsearch_fun+  {n:int}+(+A0: &RD(@[a][n]), asz: size_t(n), key: &RD(a), cmp: cmpref(a)+//+) :<> sizeLte(n) // end of [array_bsearch_fun]+//+(* ****** ****** *)+//+(*+** HX: this one is based on [bsearch] in [stdlib]+*)+fun+{a:vt0p}+array_bsearch_stdlib+  {n:int}+(+A0: &RD(@[a][n]), asz: size_t(n), key: &RD(a), cmp: cmpref(a)+) :<> Ptr0 (* found/~found : ~null/null *)+//+(* ****** ****** *)+//+fun+{a:vt0p}+array_quicksort+  {n:int}+(+  A: &(@[INV(a)][n]) >> @[a][n], n: size_t n+) :<!wrt> void // end-of-function+fun{a:vt0p}+array_quicksort$cmp(x1: &RD(a), x2: &RD(a)):<> int(*sgn*)+//+(* ****** ****** *)++(*+** HX: this one is based on [qsort] in [stdlib]+*)+fun+{a:vt0p}+array_quicksort_stdlib+  {n:int}+(+  A: &(@[INV(a)][n]) >> @[a][n], n: size_t(n), cmp: cmpref(a)+) :<!wrt> void // end of [array_quicksort_stdlib]++(* ****** ****** *)+//+fun{+a:vt0p}{b:vt0p+} array_mapto{n:int}+(+  A: &array(INV(a), n)+, B: &array(b?, n) >> array (b, n)+, n: size_t (n)+) : void // end of [array_mapto]+//+fun{+a:vt0p}{b:vt0p+} array_mapto$fwork(x: &a, y: &b? >> b): void+//+(* ****** ****** *)+//+fun{+a,b:vt0p}{c:vt0p+} array_map2to{n:int}+(+  A: &array(INV(a), n)+, B: &array(INV(b), n)+, C: &array(c?, n) >> array (c, n)+, n: size_t (n)+) : void // end of [array_map2to]+//+fun{+a,b:vt0p}{c:vt0p+} array_map2to$fwork(x: &a, y: &b, z: &c? >> c): void+//+(* ****** ****** *)+//+(*+HX-2016:+Fisher–Yates shuffle+*)+//+fun{a:vt0p}+array_permute{n:int}+  (A: &(@[INV(a)][n]) >> @[a][n], n: size_t(n)): void+//+fun{(*void*)}+array_permute$randint{n:int | n > 0}(size_t(n)): sizeLt(n)+//+(* ****** ****** *)++(* end of [array.sats] *)

@@ -0,0 +1,587 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/arrayref.atxt+** Time of generation: Thu Jan 11 11:00:09 2018+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: February, 2012 *)+(* ****** ****** *)+#define NSH (x) x // for commenting: no sharing+#define SHR (x) x // for commenting: it is shared++(* ****** ****** *)+sortdef tk = tkind++(* ****** ****** *)+sortdef t0p = t@ype and vt0p = vt@ype++(* ****** ****** *)+//+// arrayref:+// reference to an array without size attached +//+(* ****** ****** *)++#if(0)+//+// HX-2013-06:+// it is declared in [basic_dyn.sats]+//+abstype+arrayref_vt0ype_int_type+  (a: vt@ype(*elt*), n: int(*size*)) = ptr+stadef arrayref = arrayref_vt0ype_int_type+#endif+(* ****** ****** *)+//+praxi lemma_arrayref_param {a:vt0p}{n:int} (A0 : arrayref(a, n)) :+  [n >= 0] void++//+(* ****** ****** *)+//+castfn arrayref2ptr {a:vt0p}{n:int} (A : arrayref(a, n)) :<> Ptr0++//+(* ****** ****** *)+//+(*+**+** HX-2012-06:+**+** this function essentially passes the proof of+** array-view to GC (leaks it if GC is unavailable)+*)+//+castfn arrayptr_refize {a:vt0p}{l:addr}{n:int}+(A0 : arrayptr(INV(a), l, n)) :<!wrt> arrayref(a, n)++//+castfn arrayref_get_viewptr {a:vt0p}{n:int} (A0 : arrayref(a, n)) :<>+  [l:addr] (vbox(array_v(a,l,n)) | ptr(l))++(* end of [arrayref_get_viewptr] *)+//+(* ****** ****** *)+//+fun arrayref_make_arrpsz {a:vt0p}{n:int}(arrpsz(INV(a),n)) :<!wrt>+  arrayref(a, n) =+  "mac#%"++//+symintr arrayref++//+overload arrayref with arrayref_make_arrpsz++//+(* ****** ****** *)+//+fun {a:t0p} arrayref_make_elt {n:int} (asz : size_t(n), x0 : a) :<!wrt>+  arrayref(a, n)++// end of [arrayref_make_elt]+//+(* ****** ****** *)+//+fun arrayref_make_intrange { l, r : int | l <= r } ( l : int(l)+                                                   , r : int(r)+                                                   ) :<!wrt> arrayref(int, r-l)++// end of [arrayref_make_intrange]+//+(* ****** ****** *)+//+fun {a:t0p} arrayref_make_list {n:int} ( asz : int(n)+                                       , xs : list(INV(a), n)+                                       ) :<!wrt> arrayref(a, n)++// end of [arrayref_make_list]+//+fun {a:t0p} arrayref_make_rlist {n:int} ( asz : int(n)+                                        , xs : list(INV(a), n)+                                        ) :<!wrt> arrayref(a, n)++// end of [arrayref_make_rlist]+//+(* ****** ****** *)+//+// HX-2014-02:+// [A] must survive [arrayref_tail(A)]+// in order to support proper garbage-collection+//+fun {a:t0p} arrayref_head {n:pos} (A : arrayref(a, n)) :<!ref> (a)++// A[0]+fun {a:t0p} arrayref_tail {n:pos} (A : arrayref(a, n)) :<!ref>+  arrayref(a, n-1)++//+(* ****** ****** *)+//+fun {a:t0p}{tk:tk} arrayref_get_at_gint {n:int}{ i : nat | i < n }+(A0 : arrayref(a, n), i : g1int(tk, i)) :<!ref> (a)++// arrayref_get_at_gint+//+fun {a:t0p}{tk:tk} arrayref_get_at_guint {n:int}{ i : nat | i < n }+(A0 : arrayref(a, n), i : g1uint(tk, i)) :<!ref> (a)++// arrayref_get_at_guint+//+symintr arrayref_get_at++//+overload arrayref_get_at with arrayref_get_at_gint of 0++overload arrayref_get_at with arrayref_get_at_guint of 0++//+(* ****** ****** *)+//+fun {a:t0p}{tk:tk} arrayref_set_at_gint {n:int}{ i : nat | i < n }+(A : arrayref(a, n), i : g1int(tk, i), x : a) :<!refwrt> void++// end of [arrayref_set_at_gint]+//+fun {a:t0p}{tk:tk} arrayref_set_at_guint {n:int}{ i : nat | i < n }+(A : arrayref(a, n), i : g1uint(tk, i), x : a) :<!refwrt> void++// end of [arrayref_set_at_guint]+//+symintr arrayref_set_at++//+overload arrayref_set_at with arrayref_set_at_gint of 0++overload arrayref_set_at with arrayref_set_at_guint of 0++//+(* ****** ****** *)+fun {a:vt0p}{tk:tk} arrayref_exch_at_gint {n:int}{ i : nat | i < n }+(A0 : arrayref(a, n), i : g1int(tk, i), x : &a >> _) :<!refwrt> void++// arrayref_exch_at_gint+fun {a:vt0p}{tk:tk} arrayref_exch_at_guint {n:int}{ i : nat | i < n }+(A0 : arrayref(a, n), i : g1uint(tk, i), x : &a >> _) :<!refwrt> void++// arrayref_exch_at_guint+//+symintr arrayref_exch_at++//+overload arrayref_exch_at with arrayref_exch_at_gint of 0++overload arrayref_exch_at with arrayref_exch_at_guint of 0++//+(* ****** ****** *)+//+fun {a:vt0p} arrayref_interchange {n:int} ( A : arrayref(a, n)+                                          , i : sizeLt(n)+                                          , j : sizeLt(n)+                                          ) :<!refwrt> void++// end-of-function+//+(* ****** ****** *)+fun {a:vt0p} arrayref_subcirculate {n:int} ( A : arrayref(a, n)+                                           , i : sizeLt(n)+                                           , j : sizeLt(n)+                                           ) :<!refwrt> void++// end-of-function+(* ****** ****** *)+(*+fun{}+fprint_array$sep+  (out: FILEref): void+*)+fun {a:vt0p} fprint_arrayref {n:int} ( FILEref+                                     , arrayref(a,n)+                                     , asz : size_t(n)+                                     ) : void++// end of [fprint_arrayref]+fun {a:vt0p} fprint_arrayref_sep {n:int} ( FILEref+                                         , arrayref(a,n)+                                         , asz : size_t(n)+                                         , sep : NSH(string)+                                         ) : void++// end of [fprint_arrayref_sep]+(* ****** ****** *)+fun {a:t0p} arrayref_copy {n:int} (A : arrayref(a, n), n : size_t(n)) :+  arrayptr(a, n)++// end of [arrayref_copy]+(* ****** ****** *)+//+(*+fun{a:vt0p}+array_tabulate$fopr(index: size_t): (a)+*)+fun {a:vt0p} arrayref_tabulate {n:int} (asz : size_t(n)) :+  arrayref(a, n)++//+(* ****** ****** *)+(*+fun+{a:vt0p}+{env:vt0p}+array_foreach$cont+  (x: &a, env: &env): void+fun+{a:vt0p}+{env:vt0p}+array_foreach$fwork+  (x: &a >> a, env: &(env) >> _): void+*)+fun {a:vt0p} arrayref_foreach {n:int} ( A0 : arrayref(a, n)+                                      , asz : size_t(n)+                                      ) : sizeLte(n)++// end of [arrayref_foreach]+fun {a:vt0p}{env:vt0p} arrayref_foreach_env {n:int}+(A0 : arrayref(a, n), asz : size_t(n), env : &env >> _) : sizeLte(n)++// end of [arrayref_foreach_env]+(* ****** ****** *)+(*+fun+{a:vt0p}+{env:vt0p}+array_iforeach$cont+  (i: size_t, x: &a, env: &env): void+fun+{a:vt0p}+{env:vt0p}+array_iforeach$fwork+  (i: size_t, x: &a >> a, env: &(env) >> _): void+*)+fun {a:vt0p} arrayref_iforeach {n:int} ( A : arrayref(a, n)+                                       , asz : size_t(n)+                                       ) : sizeLte(n)++// end of [arrayref_iforeach]+fun {a:vt0p}{env:vt0p} arrayref_iforeach_env {n:int}+(A : arrayref(a, n), asz : size_t(n), env : &(env) >> _) : sizeLte(n)++// end of [arrayref_iforeach_env]+(* ****** ****** *)+(*+fun{a:vt0p}{env:vt0p}+array_rforeach$cont (x: &a, env: &env): void+fun{a:vt0p}{env:vt0p}+array_rforeach$fwork (x: &a >> a, env: &(env) >> _): void+*)+fun {a:vt0p} arrayref_rforeach {n:int} ( A : arrayref(a, n)+                                       , asz : size_t(n)+                                       ) : sizeLte(n)++// end of [arrayref_rforeach]+fun {a:vt0p}{env:vt0p} arrayref_rforeach_env {n:int}+(A : arrayref(a, n), asz : size_t(n), env : &(env) >> env) : sizeLte(n)++// end of [arrayref_rforeach_env]+(* ****** ****** *)+//+// HX-2017-02-19:+// Using [gcompare_ref_ref] to check+//+fun {a:vt0p} arrayref_is_ordered {n:int} ( A : arrayref(a, n)+                                         , asz : size_t(n)+                                         ) : bool++//+(* ****** ****** *)+//+fun {a:vt0p} arrayref_quicksort {n:int} ( A : arrayref(a, n)+                                        , asz : size_t(n)+                                        ) : void++//+fun {a:vt0p} arrayref_quicksort_stdlib {n:int} ( A : arrayref(a, n)+                                               , asz : size_t(n)+                                               , cmp : cmpref(a)+                                               ) : void++//+(* ****** ****** *)+(*+//+// HX: see below+//+fun+{a:t0p}+streamize_arrayref_elt+  {n:int}+  (A: arrayref(a, n), asz: size_t(n)):<!wrt> stream_vt(a)+*)+(* ****** ****** *)+//+// arrszref:+// reference to an array with its size attached+//+(* ****** ****** *)++#if(0)+//+// HX-2013-06:+// it is declared in [basic_dyn.sats]+//+abstype+arrszref_vt0ype_type (a: vt@ype) = ptr+stadef arrszref = arrszref_vt0ype_type+//+#endif+(* ****** ****** *)+symintr arrszref++(* ****** ****** *)+fun arrszref_make_arrpsz {a:vt0p}{n:int} (arrpsz(INV(a),n)) :<!wrt>+  arrszref(a)++//+overload arrszref with arrszref_make_arrpsz++//+(* ****** ****** *)+fun arrszref_make_arrayref {a:vt0p}{n:int} ( A : SHR(arrayref(a,n))+                                           , n : size_t(n)+                                           ) :<!wrt> arrszref(a)++// end of [arrszref_make_arrayref]+(* ****** ****** *)+fun {} arrszref_get_ref {a:vt0p} (A : arrszref(a)) :<> Ptr1++fun {} arrszref_get_size {a:vt0p} (A : arrszref(a)) :<> size_t++(* ****** ****** *)+//+fun arrszref_get_refsize {a:vt0p} ( A : arrszref(a)+                                  , asz : &size_t? >> size_t(n)+                                  ) :<!wrt> #[n:nat] arrayref(a, n)++// end-of-fun+//+(* ****** ****** *)+fun {a:t0p} arrszref_make_elt (asz : size_t, x : a) :<!wrt> arrszref(a)++// end of [arrszref_make_elt]+(* ****** ****** *)+fun {a:t0p} arrszref_make_list (xs : List(INV(a))) :<!wrt> arrszref(a)++// end of [arrszref_make_list]+fun {a:t0p} arrszref_make_rlist (xs : List(INV(a))) :<!wrt> arrszref(a)++// end of [arrszref_make_rlist]+(* ****** ****** *)+(*+fun{}+fprint_array$sep(out: FILEref): void+*)+fun {a:vt0p} fprint_arrszref (out : FILEref, A : arrszref(a)) : void++// end of [fprint_arrszref]+fun {a:vt0p} fprint_arrszref_sep ( out : FILEref+                                 , A : arrszref(a)+                                 , sep : NSH(string)+                                 ) : void++// end of [fprint_arrszref_sep]+(* ****** ****** *)+//+fun {a:t0p} arrszref_get_at_size (A : arrszref(a), i : size_t) +  :<!exnref> a++//+fun {a:t0p}{tk:tk} arrszref_get_at_gint ( A : arrszref(a)+                                        , i : g0int(tk)+                                        ) :<!exnref> a++//+fun {a:t0p}{tk:tk} arrszref_get_at_guint ( A : arrszref(a)+                                         , i : g0uint(tk)+                                         ) :<!exnref> a++//+symintr arrszref_get_at++overload arrszref_get_at with arrszref_get_at_gint of 0++overload arrszref_get_at with arrszref_get_at_guint of 0++//+(* ****** ****** *)+//+fun {a:t0p} arrszref_set_at_size (A : arrszref(a), i : size_t, x : a) +  :<!exnrefwrt> void++//+fun {a:t0p}{tk:tk} arrszref_set_at_gint ( A : arrszref(a)+                                        , i : g0int(tk)+                                        , x : a+                                        ) :<!exnrefwrt> void++//+fun {a:t0p}{tk:tk} arrszref_set_at_guint ( A : arrszref(a)+                                         , i : g0uint(tk)+                                         , x : a+                                         ) :<!exnrefwrt> void++//+symintr arrszref_set_at++//+overload arrszref_set_at with arrszref_set_at_gint of 0++overload arrszref_set_at with arrszref_set_at_guint of 0++//+(* ****** ****** *)+//+fun {a:vt0p} arrszref_exch_at_size ( A0 : arrszref(a)+                                   , i : size_t+                                   , x : &a >> _+                                   ) :<!exnrefwrt> void++//+fun {a:vt0p}{tk:tk} arrszref_exch_at_gint ( A0 : arrszref(a)+                                          , i : g0int(tk)+                                          , x : &a >> _+                                          ) :<!exnrefwrt> void++// end-of-function+//+fun {a:vt0p}{tk:tk} arrszref_exch_at_guint ( A0 : arrszref(a)+                                           , i : g0uint(tk)+                                           , x : &a >> _+                                           ) :<!exnrefwrt> void++// end-of-function+//+symintr arrszref_exch_at++//+overload arrszref_exch_at with arrszref_exch_at_gint of 0++overload arrszref_exch_at with arrszref_exch_at_guint of 0++(* ****** ****** *)+//+fun {a:vt0p} arrszref_interchange ( A : arrszref(a)+                                  , i : size_t+                                  , j : size_t+                                  ) :<!exnrefwrt> void++// end of [arrszref_interchange]+//+(* ****** ****** *)+//+fun {a:vt0p} arrszref_subcirculate ( A : arrszref(a)+                                   , i : size_t+                                   , j : size_t+                                   ) :<!exnrefwrt> void++// end of [arrszref_subcirculate]+//+(* ****** ****** *)+//+(*+fun{a:vt0p}+array_tabulate$fopr(size_t): (a)+*)+fun {a:vt0p} arrszref_tabulate (asz : size_t) : arrszref(a)++//+(* ****** ****** *)+//+// HX: for streamization of arrays+//+(* ****** ****** *)+//+fun {a:t0p} streamize_arrszref_elt (ASZ : arrszref(a)) : stream_vt(a)++fun {a:t0p} streamize_arrayref_elt {n:int} ( A : arrayref(a, n)+                                           , n : size_t(n)+                                           ) : stream_vt(a)++//+(* ****** ****** *)+//+// overloading for certain symbols+//+(* ****** ****** *)+//+overload [] with arrayref_get_at_gint of 0++overload [] with arrayref_set_at_gint of 0++overload [] with arrszref_get_at_gint of 0++overload [] with arrszref_set_at_gint of 0++//+overload [] with arrayref_get_at_guint of 0++overload [] with arrayref_set_at_guint of 0++overload [] with arrszref_get_at_guint of 0++overload [] with arrszref_set_at_guint of 0++//+(* ****** ****** *)+overload .head with arrayref_head++overload .tail with arrayref_tail++(* ****** ****** *)+overload size with arrszref_get_size++overload .size with arrszref_get_size++(* ****** ****** *)+overload fprint with fprint_arrayref++overload fprint with fprint_arrayref_sep++overload fprint with fprint_arrszref++overload fprint with fprint_arrszref_sep++(* ****** ****** *)+overload ptrcast with arrayref2ptr++(* ****** ****** *)+(* end of [arrayref.sats] *)

@@ -0,0 +1,676 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)++(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/arrayref.atxt+** Time of generation: Thu Jan 11 11:00:09 2018+*)++(* ****** ****** *)++(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: February, 2012 *)++(* ****** ****** *)++#define NSH (x) x // for commenting: no sharing+#define SHR (x) x // for commenting: it is shared++(* ****** ****** *)++sortdef tk = tkind++(* ****** ****** *)++sortdef t0p = t@ype and vt0p = viewt@ype++(* ****** ****** *)+//+// arrayref:+// reference to an array without size attached +//+(* ****** ****** *)++#if(0)+//+// HX-2013-06:+// it is declared in [basic_dyn.sats]+//+abstype+arrayref_vt0ype_int_type+  (a: vt@ype(*elt*), n: int(*size*)) = ptr+stadef arrayref = arrayref_vt0ype_int_type+#endif++(* ****** ****** *)+//+praxi+lemma_arrayref_param+  {a:vt0p}{n:int}+  (A0: arrayref(a, n)): [n >= 0] void+//+(* ****** ****** *)+//+castfn+arrayref2ptr+  {a:vt0p}{n:int}(A: arrayref(a, n)):<> Ptr0+//+(* ****** ****** *)+//+(*+**+** HX-2012-06:+**+** this function essentially passes the proof of+** array-view to GC (leaks it if GC is unavailable)+*)+//+castfn+arrayptr_refize+  {a:vt0p}+  {l:addr}{n:int}+(+  A0:+  arrayptr(INV(a), l, n)+) :<!wrt> arrayref(a, n)+//+castfn+arrayref_get_viewptr+  {a:vt0p}{n:int}+(+  A0: arrayref(a, n)+) :<>+[+  l:addr+] (+  vbox(array_v(a, l, n)) | ptr(l)+) (* end of [arrayref_get_viewptr] *)+//+(* ****** ****** *)+//+fun+arrayref_make_arrpsz+  {a:vt0p}{n:int}+(+  arrpsz(INV(a), n)+) :<!wrt> arrayref(a, n) = "mac#%"+//+symintr arrayref+//+overload+arrayref with arrayref_make_arrpsz+//+(* ****** ****** *)+//+fun+{a:t0p}+arrayref_make_elt+  {n:int}+(+  asz: size_t(n), x0: a+) :<!wrt> arrayref(a, n)+// end of [arrayref_make_elt]+//+(* ****** ****** *)+//+fun{}+arrayref_make_intrange+  {l,r:int | l <= r}+(+  l: int l, r: int r+) :<!wrt> arrayref(int, r-l)+// end of [arrayref_make_intrange]+//+(* ****** ****** *)+//+fun+{a:t0p}+arrayref_make_list+  {n:int}+(+  asz: int n, xs: list(INV(a), n)+) :<!wrt> arrayref(a, n)+// end of [arrayref_make_list]+//+fun+{a:t0p}+arrayref_make_rlist+  {n:int}+(+  asz: int n, xs: list(INV(a), n)+) :<!wrt> arrayref(a, n)+// end of [arrayref_make_rlist]+//+(* ****** ****** *)+//+// HX-2014-02:+// [A] must survive [arrayref_tail(A)]+// in order to support proper garbage-collection+//+fun+{a:t0p}+arrayref_head+  {n:pos} (A: arrayref(a, n)):<!ref> (a) // A[0]+fun+{a:t0p}+arrayref_tail+  {n:pos} (A: arrayref(a, n)):<!ref> arrayref(a, n-1)+//+(* ****** ****** *)+//+fun{+a:t0p}{tk:tk+} arrayref_get_at_gint+  {n:int}{i:nat | i < n}+(+A0: arrayref(a, n), i: g1int(tk, i)+) :<!ref> (a) // arrayref_get_at_gint+//+fun{+a:t0p}{tk:tk+} arrayref_get_at_guint+  {n:int}{i:nat | i < n}+(+A0: arrayref(a, n), i: g1uint(tk, i)+) :<!ref> (a) // arrayref_get_at_guint+//+symintr+arrayref_get_at+//+overload+arrayref_get_at with arrayref_get_at_gint of 0+overload+arrayref_get_at with arrayref_get_at_guint of 0+//+(* ****** ****** *)+//+fun{+a:t0p}{tk:tk+} arrayref_set_at_gint+  {n:int}{i:nat | i < n} (+  A: arrayref(a, n), i: g1int(tk, i), x: a+) :<!refwrt> void // end of [arrayref_set_at_gint]+//+fun{+a:t0p}{tk:tk+} arrayref_set_at_guint+  {n:int}{i:nat | i < n} (+  A: arrayref(a, n), i: g1uint(tk, i), x: a+) :<!refwrt> void // end of [arrayref_set_at_guint]+//+symintr+arrayref_set_at+//+overload+arrayref_set_at with arrayref_set_at_gint of 0+overload+arrayref_set_at with arrayref_set_at_guint of 0+//+(* ****** ****** *)++fun{+a:vt0p}{tk:tk+} arrayref_exch_at_gint+  {n:int}{i:nat | i < n}+(+A0: arrayref(a, n), i: g1int(tk, i), x: &a >> _+) :<!refwrt> void // arrayref_exch_at_gint++fun{+a:vt0p}{tk:tk+} arrayref_exch_at_guint+  {n:int}{i:nat | i < n}+(+A0: arrayref(a, n), i: g1uint(tk, i), x: &a >> _+) :<!refwrt> void // arrayref_exch_at_guint+//+symintr+arrayref_exch_at+//+overload+arrayref_exch_at with arrayref_exch_at_gint of 0+overload+arrayref_exch_at with arrayref_exch_at_guint of 0+//+(* ****** ****** *)+//+fun{a:vt0p}+arrayref_interchange+  {n:int}+(+  A: arrayref(a, n), i: sizeLt(n), j: sizeLt(n)+) :<!refwrt> void // end-of-function+//+(* ****** ****** *)++fun{a:vt0p}+arrayref_subcirculate+  {n:int}+(+  A: arrayref(a, n), i: sizeLt(n), j: sizeLt(n)+) :<!refwrt> void // end-of-function++(* ****** ****** *)++(*+fun{}+fprint_array$sep+  (out: FILEref): void+*)+fun{a:vt0p}+fprint_arrayref+  {n:int}+(+  FILEref+, arrayref(a, n), asz: size_t(n)+) : void // end of [fprint_arrayref]+fun{a:vt0p}+fprint_arrayref_sep+  {n:int}+( FILEref+, arrayref(a, n), asz: size_t(n), sep: NSH(string)+) : void // end of [fprint_arrayref_sep]++(* ****** ****** *)++fun{a:t0p}+arrayref_copy{n:int}+  (A: arrayref(a, n), n: size_t(n)): arrayptr(a, n)+// end of [arrayref_copy]++(* ****** ****** *)+//+(*+fun{a:vt0p}+array_tabulate$fopr(index: size_t): (a)+*)+fun{a:vt0p}+arrayref_tabulate+  {n:int}(asz: size_t(n)): arrayref(a, n)+//+(* ****** ****** *)++(*+fun+{a:vt0p}+{env:vt0p}+array_foreach$cont+  (x: &a, env: &env): void+fun+{a:vt0p}+{env:vt0p}+array_foreach$fwork+  (x: &a >> a, env: &(env) >> _): void+*)+fun+{a:vt0p}+arrayref_foreach{n:int}+(+A0: arrayref(a, n), asz: size_t(n)+) : sizeLte(n) // end of [arrayref_foreach]+fun+{a:vt0p}+{env:vt0p}+arrayref_foreach_env{n:int}+(+A0: arrayref(a, n), asz: size_t(n), env: &env >> _+) : sizeLte(n) // end of [arrayref_foreach_env]++(* ****** ****** *)++(*+fun+{a:vt0p}+{env:vt0p}+array_iforeach$cont+  (i: size_t, x: &a, env: &env): void+fun+{a:vt0p}+{env:vt0p}+array_iforeach$fwork+  (i: size_t, x: &a >> a, env: &(env) >> _): void+*)+fun+{a:vt0p}+arrayref_iforeach{n:int}+(+  A: arrayref(a, n), asz: size_t(n)+) : sizeLte(n) // end of [arrayref_iforeach]+fun+{a:vt0p}+{env:vt0p}+arrayref_iforeach_env{n:int}+(+  A: arrayref(a, n), asz: size_t(n), env: &(env) >> _+) : sizeLte(n) // end of [arrayref_iforeach_env]++(* ****** ****** *)++(*+fun{a:vt0p}{env:vt0p}+array_rforeach$cont (x: &a, env: &env): void+fun{a:vt0p}{env:vt0p}+array_rforeach$fwork (x: &a >> a, env: &(env) >> _): void+*)+fun{+a:vt0p+} arrayref_rforeach{n:int}+(+  A: arrayref(a, n), asz: size_t(n)+) : sizeLte(n) // end of [arrayref_rforeach]+fun{+a:vt0p}{env:vt0p+} arrayref_rforeach_env{n:int}+(+  A: arrayref(a, n), asz: size_t(n), env: &(env)>>env+) : sizeLte(n) // end of [arrayref_rforeach_env]++(* ****** ****** *)+//+// HX-2017-02-19:+// Using [gcompare_ref_ref] to check+//+fun+{a:vt0p}+arrayref_is_ordered+  {n:int}(A: arrayref(a, n), asz: size_t(n)): bool+//+(* ****** ****** *)+//+fun+{a:vt0p}+arrayref_quicksort+  {n:int}(A: arrayref(a, n), asz: size_t(n)): void+//+fun+{a:vt0p}+arrayref_quicksort_stdlib+  {n:int}+  (A: arrayref(a, n), asz: size_t(n), cmp: cmpref(a)): void+//+(* ****** ****** *)+(*+//+// HX: see below+//+fun+{a:t0p}+streamize_arrayref_elt+  {n:int}+  (A: arrayref(a, n), asz: size_t(n)):<!wrt> stream_vt(a)+*)+(* ****** ****** *)+//+// arrszref:+// reference to an array with its size attached+//+(* ****** ****** *)++#if(0)+//+// HX-2013-06:+// it is declared in [basic_dyn.sats]+//+abstype+arrszref_vt0ype_type (a: vt@ype) = ptr+stadef arrszref = arrszref_vt0ype_type+//+#endif++(* ****** ****** *)++symintr arrszref++(* ****** ****** *)++fun{}+arrszref_make_arrpsz+  {a:vt0p}{n:int}+  (arrpsz (INV(a), n)):<!wrt> arrszref(a)+//+overload arrszref with arrszref_make_arrpsz+//+(* ****** ****** *)++fun{}+arrszref_make_arrayref+  {a:vt0p}{n:int}+  (A: SHR(arrayref(a, n)), n: size_t(n)):<!wrt> arrszref(a)+// end of [arrszref_make_arrayref]++(* ****** ****** *)++fun{+} arrszref_get_ref{a:vt0p} (A: arrszref(a)):<> Ptr1+fun{+} arrszref_get_size{a:vt0p} (A: arrszref(a)):<> size_t++(* ****** ****** *)+//+fun{}+arrszref_get_refsize{a:vt0p}+(+  A: arrszref(a), asz: &size_t? >> size_t(n)+) :<!wrt> #[n:nat] arrayref(a, n) // end-of-fun+//+(* ****** ****** *)++fun{a:t0p}+arrszref_make_elt(asz: size_t, x: a):<!wrt> arrszref(a)+// end of [arrszref_make_elt]++(* ****** ****** *)++fun{a:t0p}+arrszref_make_list(xs: List(INV(a))):<!wrt> arrszref(a)+// end of [arrszref_make_list]++fun{a:t0p}+arrszref_make_rlist(xs: List(INV(a))):<!wrt> arrszref(a)+// end of [arrszref_make_rlist]++(* ****** ****** *)++(*+fun{}+fprint_array$sep(out: FILEref): void+*)+fun{a:vt0p}+fprint_arrszref+  (out: FILEref, A: arrszref(a)): void+// end of [fprint_arrszref]+fun{a:vt0p}+fprint_arrszref_sep+(+  out: FILEref, A: arrszref(a), sep: NSH(string)+) : void // end of [fprint_arrszref_sep]++(* ****** ****** *)+//+fun{a:t0p}+arrszref_get_at_size+  (A: arrszref(a), i: size_t):<!exnref> a+//+fun{+a:t0p}{tk:tk+} arrszref_get_at_gint+  (A: arrszref(a), i: g0int(tk)):<!exnref> a+//+fun{+a:t0p}{tk:tk+} arrszref_get_at_guint+  (A: arrszref(a), i: g0uint(tk)):<!exnref> a+//+symintr+arrszref_get_at+overload+arrszref_get_at with arrszref_get_at_gint of 0+overload+arrszref_get_at with arrszref_get_at_guint of 0+//+(* ****** ****** *)+//+fun+{a:t0p}+arrszref_set_at_size+  (A: arrszref(a), i: size_t, x: a):<!exnrefwrt> void+//+fun{+a:t0p}{tk:tk+} arrszref_set_at_gint+  (A: arrszref(a), i: g0int(tk), x: a):<!exnrefwrt> void+//+fun{+a:t0p}{tk:tk+} arrszref_set_at_guint+  (A: arrszref(a), i: g0uint(tk), x: a):<!exnrefwrt> void+//+symintr+arrszref_set_at+//+overload+arrszref_set_at with arrszref_set_at_gint of 0+overload+arrszref_set_at with arrszref_set_at_guint of 0+//+(* ****** ****** *)+//+fun+{a:vt0p}+arrszref_exch_at_size+(+A0: arrszref(a), i: size_t, x: &a >> _+) :<!exnrefwrt> void+//+fun{+a:vt0p+}{tk:tk}+arrszref_exch_at_gint+(+A0: arrszref(a), i: g0int(tk), x: &a >> _+) :<!exnrefwrt> void // end-of-function+//+fun{+a:vt0p+}{tk:tk}+arrszref_exch_at_guint+(+A0: arrszref(a), i: g0uint(tk), x: &a >> _+) :<!exnrefwrt> void // end-of-function+//+symintr+arrszref_exch_at+//+overload+arrszref_exch_at with arrszref_exch_at_gint of 0+overload+arrszref_exch_at with arrszref_exch_at_guint of 0++(* ****** ****** *)+//+fun+{a:vt0p}+arrszref_interchange+  (A: arrszref(a), i: size_t, j: size_t):<!exnrefwrt> void+// end of [arrszref_interchange]+//+(* ****** ****** *)+//+fun+{a:vt0p}+arrszref_subcirculate+  (A: arrszref(a), i: size_t, j: size_t):<!exnrefwrt> void+// end of [arrszref_subcirculate]+//+(* ****** ****** *)+//+(*+fun{a:vt0p}+array_tabulate$fopr(size_t): (a)+*)+fun{a:vt0p}+arrszref_tabulate(asz: size_t): arrszref(a)+//+(* ****** ****** *)+//+// HX: for streamization of arrays+//+(* ****** ****** *)+//+fun+{a:t0p}+streamize_arrszref_elt+  (ASZ: arrszref(a)): stream_vt(a)+fun+{a:t0p}+streamize_arrayref_elt+  {n:int}(A: arrayref(a, n), n: size_t(n)): stream_vt(a)+//+(* ****** ****** *)+//+// overloading for certain symbols+//+(* ****** ****** *)+//+overload [] with arrayref_get_at_gint of 0+overload [] with arrayref_set_at_gint of 0+overload [] with arrszref_get_at_gint of 0+overload [] with arrszref_set_at_gint of 0+//+overload [] with arrayref_get_at_guint of 0+overload [] with arrayref_set_at_guint of 0+overload [] with arrszref_get_at_guint of 0+overload [] with arrszref_set_at_guint of 0+//+(* ****** ****** *)++overload .head with arrayref_head+overload .tail with arrayref_tail++(* ****** ****** *)++overload size with arrszref_get_size+overload .size with arrszref_get_size++(* ****** ****** *)++overload fprint with fprint_arrayref+overload fprint with fprint_arrayref_sep+overload fprint with fprint_arrszref+overload fprint with fprint_arrszref_sep++(* ****** ****** *)++overload ptrcast with arrayref2ptr++(* ****** ****** *)++(* end of [arrayref.sats] *)

@@ -0,0 +1,884 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2013 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+//+// Author of the file:+// Hongwei Xi (gmhwxiATgmailDOTcom)+// Start Time: September, 2011+//+(* ****** ****** *)+#include "prelude/params.hats"++(* ****** ****** *)+//+fun patsopt_version() : string =+  "ext#%"++//+(* ****** ****** *)++#if VERBOSE_PRELUDE #then+#print "Loading [basics_dyn.sats] starts!\n"+#endif // end of [VERBOSE_PRELUDE]+(* ****** ****** *)+//+sortdef t0p = t@ype and vt0p = vt@ype++//+(* ****** ****** *)+datatype TYPE(a: vt@ype) =+  | TYPE(a) of ()++(* ****** ****** *)+//+// HX-2012: In $ATSHOME/ccomp/runtime:+// atsbool_true/atsbool_false are mapped to 1/0+// this mapping is fixed and should never be changed!+//+#define true true_bool // shorthand+#define false false_bool // shorthand++//+val true_bool: bool(true) = "mac#atsbool_true"++// = 1+val false_bool: bool(false) = "mac#atsbool_false"++// = 0+//+(* ****** ****** *)+//+// HX: [false] implies all+//+prfun false_elim { X : prop | false } () : X++//+(* ****** ****** *)+//+typedef compopr_type(a: t@ype) = (a, a) -<fun0> bool+typedef compare_type(a: t@ype) = (a, a) -<fun0> int++(*-/0/+*)+//+(* ****** ****** *)+//+praxi lemma_subcls_reflexive {c:cls} () : [c <= c] void++//+praxi lemma_subcls_transitive { c1, c2, c3 : cls | c1 <= c2; c2 <= c3 }+() : [c1 <= c3] void++//+(* ****** ****** *)+//+praxi praxi_int {i:int} () : int(i)++//+dataprop MUL_prop(int, int, int) =+  | {n:int} MULbas((0, n, 0))+  | {m:nat}{n:int}{p:int} MULind((m + 1, n, p + n)) of MUL_prop((m, n, p))+  | {m:pos}{n:int}{p:int} MULneg((~(m), n, ~(p))) of MUL_prop((m, n, p))++propdef MUL (m : int, n : int, mn : int) = MUL_prop(m, n, mn)++//+(* ****** ****** *)+//+// HX-2010-12-30: +//+absprop DIVMOD (x : int, y : int, q : int, r : int)++// end of [DIVMOD]+//+propdef DIV (x : int, y : int, q : int) = [r:int] DIVMOD(x, y, q, r)++propdef MOD (x : int, y : int, r : int) = [q:int] DIVMOD(x, y, q, r)++//+(* ****** ****** *)+dataprop EQINT(int, int) =+  | {x:int} EQINT(x, x)++prfun eqint_make { x, y : int | x == y } () : EQINT(x, y)++//+prfun eqint_make_gint {tk:tk}{x:int} (x : g1int(tk, x)) :+  [y:int] EQINT(x, y)++prfun eqint_make_guint {tk:tk}{x:int} (x : g1uint(tk, x)) :+  [y:int] EQINT(x, y)++//+(* ****** ****** *)+praxi praxi_ptr {l:addr} () : ptr(l)++praxi praxi_bool {b:bool} () : bool(b)++(* ****** ****** *)+dataprop EQADDR(addr, addr) =+  | {x:addr} EQADDR(x, x)++prfun eqaddr_make { x, y : addr | x == y } () : EQADDR(x, y)++//+prfun eqaddr_make_ptr {x:addr} (x : ptr(x)) : [y:addr] EQADDR(x, y)++//+(* ****** ****** *)+dataprop EQBOOL(bool, bool) =+  | {x:bool} EQBOOL(x, x)++prfun eqbool_make { x, y : bool | x == y } () : EQBOOL(x, y)++//+prfun eqbool_make_bool {x:bool} (x : bool(x)) : [y:bool] EQBOOL(x, y)++//+(* ****** ****** *)+//+dataprop EQTYPE(vt@ype, vt@ype) =+  | {a:vt@ype} EQTYPE((a, a))++(* ****** ****** *)+prfun prop_verify { b : bool | b } () :<prf> void++prfun prop_verify_and_add { b : bool | b } () :<prf> [b] void++(* ****** ****** *)+prfun pridentity_v {v:view} (x : !INV(v)) : void++prfun pridentity_vt {vt:vt@ype} (x : !INV(vt)) : void++(* ****** ****** *)+castfn viewptr_match {a:vt0ype}{ l1, l2 : addr | l1 == l2 }+(pf : INV(a) @ l1 | p : ptr(l2)) :<>+  [ l : addr | l == l1 ] (a @ l | ptr(l))++// end of [viewptr_match]+(* ****** ****** *)+//+val {a:vt0ype} sizeof : size_t(sizeof(a))++//+praxi lemma_sizeof {a:vt0ype} () : [sizeof(a) >= 0] void++//+(* ****** ****** *)+praxi topize {a:t0ype} (x : !INV(a) >> a?) : void++(* ****** ****** *)+castfn dataget {a:vt0ype} (x : !INV(a) >> a) : a?!++(* ****** ****** *)+//+// HX: returning the pf to GC+//+praxi mfree_gc_v_elim {l:addr} (pf : mfree_gc_v(l)) :<prf> void++// end of [mfree_gc_v_elim]+(* ****** ****** *)+praxi mfree_gcngc_v_nullify {l:addr} ( pf1 : mfree_gc_v(l)+                                     , pf1 : mfree_ngc_v(l)+                                     ) : void++// end of [mfree_gcngc_nullify_v]+(* ****** ****** *)+//+fun cloptr_free {a:t0p}(pclo : cloptr(a)) :<!wrt> void =+  "mac#%"++//+overload free with cloptr_free of 0++//+(* ****** ****** *)+//+fun {a:t0p} lazy_force (lazyval : lazy(INV(a))) :<!laz> (a)++//+fun {a:vt0p} lazy_vt_force (lazyval : lazy_vt(INV(a))) :<!all> (a)++//+(*+//+// HX-2016-08:+// this is assumed internally!+//+overload ! with lazy_force of 0+overload ! with lazy_vt_force of 0+*)+//+(* ****** ****** *)+//+// HX-2013:+// macro implemented in [pats_ccomp_instrset]+//+fun lazy_vt_free {a:vt0p}(lazyval : lazy_vt(a)) :<!wrt> void =+  "mac#%"++//+overload ~ with lazy_vt_free of 0++overload free with lazy_vt_free of 0++//+(* ****** ****** *)+//+// HX-2014:+// macro implemented in [pats_ccomp_instrset]+//+fun lazy2cloref {a:t0p}(lazy(a)) : () -<cloref1> (a) =+  "mac#%"++//+(* ****** ****** *)+(*+// HX-2012-05-23: this seems TOO complicated!+(*+** HX-2012-03: handling read-only views and vtypes+*)+castfn+read_getval // copy out a non-linear value+  {a:t@ype}{s:int}{n:int} (x: !READ (a, s, n)):<> a+// end of [read_getval]++praxi+read_takeout{v:view}+  (pf: !v >> READOUT (v, s)): #[s:int] READ (v, s, 0)+// end of [read_takeout]+praxi+read_addback // HX: there is no need to check+  {v1:view}{v2:view}{s:int} // if v1 and v2 match+  (pf1: !READOUT (v1, s) >> v1, pf2: READ (v2, s, 0)): void+// end of [read0_addback]++praxi+read_split+  {v:view}{s:int}{n:int}+  (pf: !READ (v, s, n) >> READ (v, s, n+1)): READ (v, s, 0)+// end of [read_split]+praxi+read_unsplit // HX: there is no need to check+  {v1:view}{v2:view}{s:int}{n1,n2:int} // if v1 and v2 match+  (pf1: READ (v1, s, n1), pf2: READ (v2, s, n2)): READ (v1, s, n1+n2-1)+// end of [read_unsplit]+*)+(* ****** ****** *)+//+castfn stamp_t {a:t@ype} (x : INV(a)) :<> stamped_t(a)++// end of [stamp_t]+castfn stamp_vt {a:vt@ype} (x : INV(a)) :<> stamped_vt(a)++// end of [stamp_vt]+//+(* ****** ****** *)+//+castfn unstamp_t {a:t@ype}{x:int} (x : stamped_t(INV(a), x)) :<> a++// end of [unstamp_t]+castfn unstamp_vt {a:vt@ype}{x:int} (x : stamped_vt(INV(a), x)) :<> a++// end of [unstamp_vt]+//+(* ****** ****** *)+//+castfn stamped_t2vt {a:t@ype}{x:int} (x : stamped_t(INV(a), x)) :<>+  stamped_vt(a, x)++// end of [stamped_t2vt]+//+castfn stamped_vt2t {a:t@ype}{x:int} (x : stamped_vt(INV(a), x)) :<>+  stamped_t(a, x)++// end of [stamped_vt2t]+//+fun {a:t@ype} stamped_vt2t_ref {x:int} (x : &stamped_vt(INV(a), x)) :<>+  stamped_t(a, x)++//+(* ****** ****** *)+//+praxi vcopyenv_v_decode {v:view} (x : vcopyenv_v(v)) : vtakeout0(v)++castfn vcopyenv_vt_decode {vt:vt0p} (x : vcopyenv_vt(vt)) :+  vttakeout0(vt)++//+overload decode with vcopyenv_v_decode++overload decode with vcopyenv_vt_decode++//+(* ****** ****** *)+//+// HX: the_null_ptr = (void*)0+//+val the_null_ptr: ptr(null) = "mac#the_atsptr_null"++//+(* ****** ****** *)+//+praxi lemma_addr_param {l:addr} () : [l >= null] void++//+(* ****** ****** *)+praxi lemma_string_param {n:int} (x : string(n)) : [n >= 0] void++// end of [lemma_string_param]+praxi lemma_stropt_param {n:int} (x : stropt(n)) : [n >= ~1] void++// end of [lemma_stropt_param]+(* ****** ****** *)+//+dataprop SGN(int, int) =+  | SGNzero((0, 0))+  | {i:neg} SGNneg((i, ~1))+  | {i:pos} SGNpos((i, 1))++(* ****** ****** *)+//+// HX-2012-06:+// indication of the failure of+exception AssertExn of ()++// an assertion+//+(* ****** ****** *)+//+// HX-2012-06:+// indication of something expected+exception NotFoundExn of ()++// to be found but not+//+(* ****** ****** *)+//+exception GenerallyExn of (string)++// for unspecified causes+(*+exception GenerallyExn2 of (string, ptr(*data*)) // for unspecified causes+*)+//+(* ****** ****** *)+//+// HX-2012-07:+// indication of a function argument being+exception IllegalArgExn of (string)++// out of its domain+//+(* ****** ****** *)+praxi __vfree_exn(x : exn) :<> void++// for freeing nullary exception-con+(* ****** ****** *)+//+datatype unit =+  | unit of ()++dataprop unit_p =+  | unit_p of ()++dataview unit_v =+  | unit_v of ()++datavtype unit_vt =+  | unit_vt of ()++//+prfun unit_v_elim(pf : unit_v) : void++//+(* ****** ****** *)+//+abstype boxed_t0ype_type(a: t@ype+) = unit+absvtype boxed_vt0ype_vtype(a: vt@ype+) = unit++//+vtypedef boxed(a: vt@ype) = boxed_vt0ype_vtype(a)+vtypedef boxed_vt(a: vt@ype) = boxed_vt0ype_vtype(a)++//+typedef boxed(a: t@ype) = boxed_t0ype_type(a)+typedef boxed_t(a: t@ype) = boxed_t0ype_type(a)++//+fun {a:type} box  : (INV(a)) -> boxed_t(a)++fun {a:type} unbox  : boxed_t(INV(a)) -> (a)++fun {a:vtype} box_vt  : (INV(a)) -> boxed_vt(a)++fun {a:vtype} unbox_vt  : boxed_vt(INV(a)) -> (a)++//+(* ****** ****** *)+//+stadef array (a: vt@ype, n: int) = @[a][n]++//+viewdef array_v(a: vt@ype, l: addr, n: int) = @[a][n] @ l++//+absvtype arrayptr_vt0ype_addr_int_vtype( a: vt0ype++                                       , l: addr+                                       , n: int+                                       ) = ptr(l)++stadef arrayptr  = arrayptr_vt0ype_addr_int_vtype++vtypedef arrayptr(a: vt0p, n: int) = [l:addr] arrayptr(a, l, n)++//+abstype arrayref_vt0ype_int_type(a: vt@ype, n: int) = ptr++stadef arrayref  = arrayref_vt0ype_int_type++//+abstype arrszref_vt0ype_type(a: vt@ype) = ptr++typedef arrszref(a: vt0p) = arrszref_vt0ype_type(a)++//+(* ****** ****** *)+//+datatype list_t0ype_int_type(a: t@ype+, int) =+  | list_nil(a, 0) of ()+  | { n : int | n >= 0 } list_cons( a+                                  , n+1+                                  ) of (a, list_t0ype_int_type(a, n))++stadef list  = list_t0ype_int_type++typedef List(a: t0p) = [n:int] list(a, n)+typedef List0(a: t0p) = [ n : int | n >= 0 ] list(a, n)+typedef List1(a: t0p) = [ n : int | n >= 1 ] list(a, n)+typedef listLt(a: t0p, n: int) = [ k : nat | k < n ] list(a, k)+typedef listLte(a: t0p, n: int) = [ k : nat | k <= n ] list(a, k)+typedef listGt(a: t0p, n: int) = [ k : int | k > n ] list(a, k)+typedef listGte(a: t0p, n: int) = [ k : int | k >= n ] list(a, k)+typedef listBtw( a: t0p+               , m: int+               , n: int+               ) = [ k : int | m <= k; k < n ] list(a, k)+typedef listBtwe( a: t0p+                , m: int+                , n: int+                ) = [ k : int | m <= k; k <= n ] list(a, k)++//+(* ****** ****** *)+//+datavtype list_vt0ype_int_vtype(a: vt@ype+, int) =+  | list_vt_nil(a, 0) of ()+  | { n : int | n >= 0 } list_vt_cons( a+                                     , n+1+                                     ) of (a, list_vt0ype_int_vtype(a, n))++stadef list_vt  = list_vt0ype_int_vtype++vtypedef List_vt(a: vt0p) = [n:int] list_vt(a, n)+vtypedef List0_vt(a: vt0p) = [ n : int | n >= 0 ] list_vt(a, n)+vtypedef List1_vt(a: vt0p) = [ n : int | n >= 1 ] list_vt(a, n)+vtypedef listLt_vt(a: vt0p, n: int) = [ k : nat | k < n ] list_vt(a, k)+vtypedef listLte_vt(a: vt0p, n: int) =+  [ k : nat | k <= n ] list_vt(a, k)+vtypedef listGt_vt(a: vt0p, n: int) = [ k : int | k > n ] list_vt(a, k)+vtypedef listGte_vt(a: vt0p, n: int) =+  [ k : int | k >= n ] list_vt(a, k)+vtypedef listBtw_vt(a: vt0p, m: int, n: int) =+  [ k : int | m <= k; k < n ] list_vt(a, k)+vtypedef listBtwe_vt(a: vt0p, m: int, n: int) =+  [ k : int | m <= k; k <= n ] list_vt(a, k)++//+(* ****** ****** *)+//+datatype stream_con(a: t@ype+) =+  | stream_nil of ()+  | stream_cons of (a, stream(a))   where+                                    stream (a: t@ype) = lazy(stream_con(a))++//+datavtype stream_vt_con(a: vt@ype+) =+  | stream_vt_nil of ()+  | stream_vt_cons of (a, stream_vt(a))   where+                                          stream_vt (a: vt@ype) = lazy_vt(stream_vt_con(a))++//+(* ****** ****** *)+//+datatype option_t0ype_bool_type(a: t@ype+, bool) =+  | Some(a, true) of (INV(a))+  | None(a, false)++// end of [datatype]+stadef option  = option_t0ype_bool_type++typedef Option(a: t0p) = [b:bool] option(a, b)++//+datavtype option_vt0ype_bool_vtype(a: vt@ype+, bool) =+  | Some_vt(a, true) of (INV(a))+  | None_vt(a, false)++// end of [option_vt0ype_bool_vtype]+stadef option_vt  = option_vt0ype_bool_vtype++vtypedef Option_vt(a: vt0p) = [b:bool] option_vt(a, b)++//+(* ****** ****** *)+//+praxi opt_some {a:vt0p} (x : !INV(a) >> opt(a, true)) :<prf> void++praxi opt_unsome {a:vt0p} (x : !opt(INV(a), true) >> a) :<prf> void++//+fun {a:vt0p} opt_unsome_get (x : &opt(INV(a), true) >> a?) : (a)++//+praxi opt_none {a:vt0p} (x : !(a?) >> opt(a, false)) :<prf> void++praxi opt_unnone {a:vt0p} (x : !opt(INV(a), false) >> a?) :<prf> void++//+praxi opt_clear {a:t0p}{b:bool} (x : !opt(INV(a), b) >> a?) :<prf> void++//+(* ****** ****** *)+//+dataprop or_prop_prop_int_prop(a0: prop+, a1: prop+, int) =+  | POR_l(a0, a1, 0) of (INV(a0))+  | POR_r(a0, a1, 1) of (INV(a1))++dataview or_view_view_int_view(a0: view+, a1: view+, int) =+  | VOR_l(a0, a1, 0) of (INV(a0))+  | VOR_r(a0, a1, 1) of (INV(a1))++//+stadef por  = or_prop_prop_int_prop+stadef vor  = or_view_view_int_view++//+dataprop option_prop_bool_prop(a: prop+, bool) =+  | Some_p((a, true)) of (INV(a))+  | None_p((a, false))++stadef option_p  = option_prop_bool_prop++//+dataview option_view_bool_view(a: view+, bool) =+  | Some_v(a, true) of (INV(a))+  | None_v(a, false)++// end of [option_view_bool_view]+stadef option_v  = option_view_bool_view++//+(* ****** ****** *)+//+absvt@ype arrayopt(a: vt0p, n: int, b: bool) = array(a, n)++//+praxi arrayopt_some {a:vt0p}{n:int}+(A : &array(a, n) >> arrayopt(a, n, true)) : void++praxi arrayopt_none {a:vt0p}{n:int}+(A : &array(a?, n) >> arrayopt(a, n, false)) : void++praxi arrayopt_unsome {a:vt0p}{n:int}+(A : &arrayopt(a, n, true) >> array(a, n)) : void++praxi arrayopt_unnone {a:vt0p}{n:int}+(A : &arrayopt(a, n, false) >> array(a?, n)) : void++//+(* ****** ****** *)+absvtype argv_int_vtype(n: int) = ptr++stadef argv  = argv_int_vtype++(*+[argv_takeout_strarr] is declared in prelude/SATS/extern.sats+[argv_takeout_parrnull] is declared in prelude/SATS/extern.sats+*)+(* ****** ****** *)+praxi lemma_argv_param {n:int} (argv : !argv(n)) : [n >= 0] void++// end of [praxi]+(* ****** ****** *)+//+fun argv_get_at {n:int}(argv : !argv(n), i : natLt(n)) :<> string =+  "mac#%"++fun argv_set_at {n:int}(argv : !argv(n), i : natLt(n), x : string) +  :<!wrt> void =+  "mac#%"++//+overload [] with argv_get_at++overload [] with argv_set_at++//+(* ****** ****** *)+//+fun listize_argc_argv {n:int} (argc : int(n), argv : !argv(n)) :+  list_vt(string, n)++//+(* ****** ****** *)+//+symintr main0++//+fun main_void_0() : void =+  "ext#mainats_void_0"++fun main_argc_argv_0 { n : int | n >= 1 }( argc : int(n)+                                         , argv : !argv(n)+                                         ) : void =+  "ext#mainats_argc_argv_0"++//+overload main0 with main_void_0++overload main0 with main_argc_argv_0++//+(* ****** ****** *)+//+symintr main++//+fun main_void_int() : int =+  "ext#mainats_void_int"++fun main_argc_argv_int { n : int | n >= 1 }( argc : int(n)+                                           , argv : !argv(n)+                                           ) : int =+  "ext#mainats_argc_argv_int"++fun main_argc_argv_envp_int { n : int | n >= 1 }( argc : int(n)+                                                , argv : !argv(n)+                                                , envp : ptr+                                                ) : int =+  "ext#mainats_argc_argv_envp_int"++//+overload main with main_void_int++overload main with main_argc_argv_int++overload main with main_argc_argv_envp_int++//+(* ****** ****** *)+//+fun exit(ecode : int) :<!exn> {a:t0p} (a) =+  "mac#%"++fun exit_errmsg(ecode : int, msg : string) :<!exn> {a:t0p} (a) =+  "mac#%"++//+(*+fun exit_fprintf{ts:types}+(+  ecode: int, out: FILEref, fmt: printf_c ts, args: ts+) :<!exn> {a:vt0p}(a) = "mac#%" // end of [exit_fprintf]+*)+//+(* *****p* ****** *)+//+fun exit_void(ecode : int) :<!exn> void =+  "mac#%"++fun exit_errmsg_void(ecode : int, msg : string) :<!exn> void =+  "mac#%"++//+(* ****** ****** *)+//+fun assert_bool0(x : bool) :<!exn> void =+  "mac#%"++fun assert_bool1 {b:bool}(x : bool(b)) :<!exn> [b] void =+  "mac#%"++//+overload assert with assert_bool0 of 0++overload assert with assert_bool1 of 10++//+(* ****** ****** *)+//+fun assertexn_bool0(x : bool) :<!exn> void++fun assertexn_bool1 {b:bool} (x : bool(b)) :<!exn> [b] void++//+symintr assertexn++overload assertexn with assertexn_bool0 of 0++overload assertexn with assertexn_bool1 of 10++//+(* ****** ****** *)+//+fun assert_errmsg_bool0(x : bool, msg : string) :<!exn> void =+  "mac#%"++fun assert_errmsg_bool1 {b:bool}(x : bool(b), msg : string) :<!exn>+  [b] void =+  "mac#%"++//+symintr assert_errmsg++overload assert_errmsg with assert_errmsg_bool0 of 0++overload assert_errmsg with assert_errmsg_bool1 of 10++//+(* ****** ****** *)+//+fun assert_errmsg2_bool0(x : bool, msg1 : string, msg2 : string) :<!exn>+  void =+  "mac#%"++fun assert_errmsg2_bool1 {b:bool}( x : bool(b)+                                 , msg1 : string+                                 , msg2 : string+                                 ) :<!exn> [b] void =+  "mac#%"++//+symintr assert_errmsg2++overload assert_errmsg2 with assert_errmsg2_bool0 of 0++overload assert_errmsg2 with assert_errmsg2_bool1 of 10++//+(* ****** ****** *)+//+datasort file_mode =+  | file_mode_r+  | file_mode_w+  | file_mode_rw++// end of [file_mode]+//+(* ****** ****** *)+local+  //+  stadef r () = file_mode_r()+  stadef w () = file_mode_w()+  stadef rw () = file_mode_rw()+  +  //+in+  (* in-of-local *)+  (* ****** ****** *)+  abstype file_mode(file_mode) = string+  +  typedef file_mode = [fm:file_mode] file_mode(fm)+  +  (* ****** ****** *)+  sortdef fmode = file_mode+  +  typedef fmode(fm: fmode) = file_mode(fm)+  typedef fmode = file_mode+  +  (* ****** ****** *)+  dataprop file_mode_lte(fmode, fmode) =+    | {m:fmode} file_mode_lte_refl((m, m))+    | { m1, m2, m3 : fmode } file_mode_lte_tran((m1, m3)) of (file_mode_lte( m1+                                                                           , m2+                                                                           ), file_mode_lte(m2, m3))+    | {m:fmode} file_mode_lte_rw_r(rw(), r()) of ()+    | {m:fmode} file_mode_lte_rw_w(rw(), w()) of ()+  +  (* ****** ****** *)+  //+  prval file_mode_lte_r_r : file_mode_lte(r(), r())+  +  // impled in [filebas_prf.dats]+  prval file_mode_lte_w_w : file_mode_lte(w(), w())+  +  // impled in [filebas_prf.dats]+  prval file_mode_lte_rw_rw : file_mode_lte(rw(), rw())+  +  // impled in [filebas_prf.dats]+  //+  (* ****** ****** *)+end++// end of [local]+(* ****** ****** *)+abstype FILEref_type = ptr++typedef FILEref = FILEref_type++(* ****** ****** *)+//+typedef print_type(a: t0p) = (a) -> void+typedef prerr_type(a: t0p) = (a) -> void+typedef fprint_type(a: t0p) = (FILEref, a) -> void++//+typedef print_vtype(a: vt0p) = (!a) -> void+typedef prerr_vtype(a: vt0p) = (!a) -> void+typedef fprint_vtype(a: vt0p) = (FILEref, !a) -> void++//+(* ****** ****** *)+(*+fun print_void(x: void): void = "mac#%"+*)+(* ****** ****** *)+fun print_newline() : void =+  "mac#%"++fun prerr_newline() : void =+  "mac#%"++fun fprint_newline(out : FILEref) : void =+  "mac#%"++(* ****** ****** *)++#if VERBOSE_PRELUDE #then+#print "Loading [basics_dyn.sats] finishes!\n"+#endif // end of [VERBOSE_PRELUDE]+(* ****** ****** *)+(* end of [basics_dyn.sats] *)

@@ -0,0 +1,918 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2013 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)+//+// Author of the file:+// Hongwei Xi (gmhwxiATgmailDOTcom)+// Start Time: September, 2011+//+(* ****** ****** *)++#include "prelude/params.hats"++(* ****** ****** *)+//+fun+patsopt_version(): string = "ext#%"+//+(* ****** ****** *)++#if VERBOSE_PRELUDE #then+#print "Loading [basics_dyn.sats] starts!\n"+#endif // end of [VERBOSE_PRELUDE]++(* ****** ****** *)+//+sortdef t0p = t@ype and vt0p = vt@ype+//+(* ****** ****** *)++datatype TYPE(a:vt@ype) = TYPE(a) of ()++(* ****** ****** *)+//+// HX-2012: In $ATSHOME/ccomp/runtime:+// atsbool_true/atsbool_false are mapped to 1/0+// this mapping is fixed and should never be changed!+//+#define true true_bool // shorthand+#define false false_bool // shorthand+//+val true_bool : bool(true)  = "mac#atsbool_true" // = 1+val false_bool : bool(false) = "mac#atsbool_false" // = 0+//+(* ****** ****** *)+//+// HX: [false] implies all+//+prfun false_elim{X:prop | false} ((*void*)): X+//+(* ****** ****** *)+//+typedef+compopr_type(a: t@ype) = (a, a) -<fun0> bool+typedef+compare_type(a: t@ype) = (a, a) -<fun0> int(*-/0/+*)+//+(* ****** ****** *)+//+praxi+lemma_subcls_reflexive+  {c:cls}((*void*)): [c <= c] void+//+praxi+lemma_subcls_transitive+  {c1,c2,c3:cls | c1 <= c2; c2 <= c3}(): [c1 <= c3] void+//+(* ****** ****** *)+//+praxi+praxi_int{i:int} ((*void*)): int(i)+//+dataprop+MUL_prop+(+  int, int, int+) = // MUL_prop+  | {n:int}+    MULbas (0, n, 0)+  | {m:nat}{n:int}{p:int}+    MULind (m+1, n, p+n) of MUL_prop (m, n, p)+  | {m:pos}{n:int}{p:int}+    MULneg (~(m), n, ~(p)) of MUL_prop (m, n, p)+//+propdef MUL(m:int, n:int, mn:int) = MUL_prop(m, n, mn)+//+(* ****** ****** *)+//+// HX-2010-12-30: +//+absprop+DIVMOD (+  x:int, y: int, q: int, r: int // x = q * y + r+) // end of [DIVMOD]+//+propdef DIV (x:int, y:int, q:int) = [r:int] DIVMOD(x, y, q, r)+propdef MOD (x:int, y:int, r:int) = [q:int] DIVMOD(x, y, q, r)+//+(* ****** ****** *)++dataprop+EQINT(int, int) = {x:int} EQINT(x, x)+//+prfun+eqint_make{x,y:int | x == y}(): EQINT(x, y)+//+prfun+eqint_make_gint+  {tk:tk}{x:int}(x: g1int(tk, x)): [y:int] EQINT(x, y)+prfun+eqint_make_guint+  {tk:tk}{x:int}(x: g1uint(tk, x)): [y:int] EQINT(x, y)+//+(* ****** ****** *)++praxi praxi_ptr{l:addr} ((*void*)): ptr(l)+praxi praxi_bool{b:bool} ((*void*)): bool(b)++(* ****** ****** *)++dataprop+EQADDR(addr, addr) = {x:addr} EQADDR(x, x)+//+prfun+eqaddr_make{x,y:addr | x == y}(): EQADDR(x, y)+//+prfun+eqaddr_make_ptr{x:addr}(x: ptr(x)): [y:addr] EQADDR(x, y)+//+(* ****** ****** *)++dataprop+EQBOOL(bool, bool) = {x:bool} EQBOOL(x, x)+//+prfun+eqbool_make{x,y:bool | x == y}(): EQBOOL(x, y)+//+prfun+eqbool_make_bool{x:bool}(x: bool(x)): [y:bool] EQBOOL(x, y)+//+(* ****** ****** *)+//+dataprop+EQTYPE(vt@ype, vt@ype) = {a:vt@ype} EQTYPE (a, a)+//+(* ****** ****** *)++prfun+prop_verify{b:bool | b} ():<prf> void+prfun+prop_verify_and_add{b:bool | b} ():<prf> [b] void++(* ****** ****** *)++prfun pridentity_v{v:view} (x: !INV(v)): void+prfun pridentity_vt{vt:viewt@ype} (x: !INV(vt)): void++(* ****** ****** *)++castfn+viewptr_match+{a:vt0ype}{l1,l2:addr|l1==l2}+(+  pf: INV(a) @ l1 | p: ptr(l2)+) :<> [l:addr | l==l1] (a @ l | ptr(l))+// end of [viewptr_match]++(* ****** ****** *)+//+val{+a:vt0ype+} sizeof : size_t(sizeof(a))+//+praxi+lemma_sizeof+  {a:vt0ype}((*void*)): [sizeof(a) >= 0] void+//+(* ****** ****** *)++praxi topize{a:t0ype} (x: !INV(a) >> a?): void++(* ****** ****** *)++castfn dataget{a:vt0ype} (x: !INV(a) >> a): a?!++(* ****** ****** *)+//+// HX: returning the pf to GC+//+praxi+mfree_gc_v_elim+  {l:addr} (pf: mfree_gc_v l):<prf> void+// end of [mfree_gc_v_elim]++(* ****** ****** *)++praxi+mfree_gcngc_v_nullify+  {l:addr} (+  pf1: mfree_gc_v(l), pf1: mfree_ngc_v(l)+) : void // end of [mfree_gcngc_nullify_v]++(* ****** ****** *)+//+fun+cloptr_free+  {a:t0p}+  (pclo: cloptr(a)):<!wrt> void = "mac#%"+//+overload free with cloptr_free of 0+//+(* ****** ****** *)+//+fun+{a:t0p}+lazy_force(lazyval: lazy(INV(a))):<!laz> (a)+//+fun+{a:vt0p}+lazy_vt_force(lazyval: lazy_vt(INV(a))):<!all> (a)+//+(*+//+// HX-2016-08:+// this is assumed internally!+//+overload ! with lazy_force of 0+overload ! with lazy_vt_force of 0+*)+//+(* ****** ****** *)+//+// HX-2013:+// macro implemented in [pats_ccomp_instrset]+//+fun+lazy_vt_free+  {a:vt0p}+  (lazyval: lazy_vt(a)):<!wrt> void = "mac#%"+//+overload ~ with lazy_vt_free of 0+overload free with lazy_vt_free of 0+//+(* ****** ****** *)+//+// HX-2014:+// macro implemented in [pats_ccomp_instrset]+//+fun+lazy2cloref+  {a:t0p}+  (lazy(a)): ((*void*)) -<cloref1> (a) = "mac#%"+//+(* ****** ****** *)++(*+// HX-2012-05-23: this seems TOO complicated!+(*+** HX-2012-03: handling read-only views and vtypes+*)+castfn+read_getval // copy out a non-linear value+  {a:t@ype}{s:int}{n:int} (x: !READ (a, s, n)):<> a+// end of [read_getval]++praxi+read_takeout{v:view}+  (pf: !v >> READOUT (v, s)): #[s:int] READ (v, s, 0)+// end of [read_takeout]+praxi+read_addback // HX: there is no need to check+  {v1:view}{v2:view}{s:int} // if v1 and v2 match+  (pf1: !READOUT (v1, s) >> v1, pf2: READ (v2, s, 0)): void+// end of [read0_addback]++praxi+read_split+  {v:view}{s:int}{n:int}+  (pf: !READ (v, s, n) >> READ (v, s, n+1)): READ (v, s, 0)+// end of [read_split]+praxi+read_unsplit // HX: there is no need to check+  {v1:view}{v2:view}{s:int}{n1,n2:int} // if v1 and v2 match+  (pf1: READ (v1, s, n1), pf2: READ (v2, s, n2)): READ (v1, s, n1+n2-1)+// end of [read_unsplit]+*)+(* ****** ****** *)+//+castfn+stamp_t+  {a:t@ype}(x: INV(a)):<> stamped_t(a)+// end of [stamp_t]+castfn+stamp_vt+  {a:vt@ype}(x: INV(a)):<> stamped_vt(a)+// end of [stamp_vt]+//+(* ****** ****** *)+//+castfn+unstamp_t+  {a:t@ype}{x:int}(x: stamped_t(INV(a), x)):<> a+// end of [unstamp_t]+castfn+unstamp_vt+  {a:vt@ype}{x:int}(x: stamped_vt(INV(a), x)):<> a+// end of [unstamp_vt]+//+(* ****** ****** *)+//+castfn+stamped_t2vt+  {a:t@ype}{x:int}+  (x: stamped_t(INV(a), x)):<> stamped_vt(a, x)+// end of [stamped_t2vt]+//+castfn+stamped_vt2t+  {a:t@ype}{x:int}+  (x: stamped_vt(INV(a), x)):<> stamped_t(a, x)+// end of [stamped_vt2t]+//+fun{a:t@ype}+stamped_vt2t_ref{x:int}+  (x: &stamped_vt(INV(a), x)):<> stamped_t(a, x)+//+(* ****** ****** *)+//+praxi+vcopyenv_v_decode+  {v:view}(x: vcopyenv_v(v)): vtakeout0(v)+castfn+vcopyenv_vt_decode+  {vt:vt0p}(x: vcopyenv_vt(vt)): vttakeout0(vt)+//+overload decode with vcopyenv_v_decode+overload decode with vcopyenv_vt_decode+//+(* ****** ****** *)+//+// HX: the_null_ptr = (void*)0+//+val+the_null_ptr+  : ptr(null) = "mac#the_atsptr_null"+//+(* ****** ****** *)+//+praxi+lemma_addr_param+  {l:addr}((*void*)): [l >= null] void+//+(* ****** ****** *)++praxi+lemma_string_param+  {n:int} (x: string(n)): [n >= 0] void+// end of [lemma_string_param]+praxi+lemma_stropt_param+  {n:int} (x: stropt(n)): [n >= ~1] void+// end of [lemma_stropt_param]++(* ****** ****** *)+//+dataprop+SGN (int, int) =+  | SGNzero (0, 0)+  | {i:neg} SGNneg (i, ~1) | {i:pos} SGNpos (i,  1)+// end of [SGN] // end of [dataprop]+//+(* ****** ****** *)+//+// HX-2012-06:+// indication of the failure of+exception AssertExn of () // an assertion+//+(* ****** ****** *)+//+// HX-2012-06:+// indication of something expected+exception NotFoundExn of () // to be found but not+//+(* ****** ****** *)+//+exception GenerallyExn of (string) // for unspecified causes+(*+exception GenerallyExn2 of (string, ptr(*data*)) // for unspecified causes+*)+//+(* ****** ****** *)+//+// HX-2012-07:+// indication of a function argument being+exception IllegalArgExn of (string) // out of its domain+//+(* ****** ****** *)++praxi __vfree_exn (x: exn):<> void // for freeing nullary exception-con++(* ****** ****** *)+//+datatype unit = unit of ()+dataprop unit_p = unit_p of ()+dataview unit_v = unit_v of ()+datavtype unit_vt = unit_vt of ()+//+prfun unit_v_elim (pf: unit_v): void+//+(* ****** ****** *)+//+abstype+boxed_t0ype_type(a:t@ype+) = unit+absvtype+boxed_vt0ype_vtype(a:vt@ype+) = unit+//+vtypedef+boxed(a:vt@ype) = boxed_vt0ype_vtype(a)+vtypedef+boxed_vt(a:vt@ype) = boxed_vt0ype_vtype(a)+//+typedef boxed(a:t@ype) = boxed_t0ype_type(a)+typedef boxed_t(a:t@ype) = boxed_t0ype_type(a)+//+fun{a:type} box: (INV(a)) -> boxed_t(a)+fun{a:type} unbox: boxed_t(INV(a)) -> (a)+fun{a:vtype} box_vt: (INV(a)) -> boxed_vt(a)+fun{a:vtype} unbox_vt: boxed_vt(INV(a)) -> (a)+//+(* ****** ****** *)+//+stadef+array(a:vt@ype, n:int) = @[a][n]+//+viewdef+array_v+  (a:vt@ype, l:addr, n:int) = @[a][n] @ l+//+absvtype+arrayptr_vt0ype_addr_int_vtype+  (a:vt0ype+, l:addr, n:int(*size*)) = ptr(l)+stadef+arrayptr = arrayptr_vt0ype_addr_int_vtype+vtypedef+arrayptr+  (a:vt0p, n:int) = [l:addr] arrayptr(a, l, n)+//+abstype+arrayref_vt0ype_int_type+  (a:vt@ype(*elt*), n:int(*size*)) = ptr+stadef arrayref = arrayref_vt0ype_int_type+//+abstype+arrszref_vt0ype_type(a: vt@ype) = ptr+typedef arrszref(a:vt0p) = arrszref_vt0ype_type(a)+//+(* ****** ****** *)+//+datatype+// t@ype+: covariant+list_t0ype_int_type+  (a:t@ype+, int) =+  | list_nil(a, 0) of ()+  | {n:int | n >= 0}+    list_cons(a, n+1) of (a, list_t0ype_int_type(a, n))+// end of [datatype]+stadef list = list_t0ype_int_type+typedef+List(a:t0p) = [n:int] list(a, n)+typedef+List0(a:t0p) = [n:int | n >= 0] list(a, n)+typedef+List1(a:t0p) = [n:int | n >= 1] list(a, n)+typedef listLt+  (a:t0p, n:int) = [k:nat | k < n] list(a, k)+typedef listLte+  (a:t0p, n:int) = [k:nat | k <= n] list(a, k)+typedef listGt+  (a:t0p, n:int) = [k:int | k > n] list(a, k)+typedef listGte+  (a:t0p, n:int) = [k:int | k >= n] list(a, k)+typedef listBtw+  (a:t0p, m:int, n:int) = [k:int | m <= k; k < n] list(a, k)+typedef listBtwe+  (a:t0p, m:int, n:int) = [k:int | m <= k; k <= n] list(a, k)+//+(* ****** ****** *)+//+datavtype+// vt@ype+: covariant+list_vt0ype_int_vtype+  (a:vt@ype+, int) =+  | list_vt_nil(a, 0) of ()+  | {n:int | n >= 0}+    list_vt_cons(a, n+1) of (a, list_vt0ype_int_vtype(a, n))+// end of [list_vt0ype_int_vtype]+stadef list_vt = list_vt0ype_int_vtype+vtypedef+List_vt(a:vt0p) = [n:int] list_vt(a, n)+vtypedef+List0_vt(a:vt0p) = [n:int | n >= 0] list_vt(a, n)+vtypedef+List1_vt(a:vt0p) = [n:int | n >= 1] list_vt(a, n)+vtypedef listLt_vt+  (a:vt0p, n:int) = [k:nat | k < n] list_vt(a, k)+vtypedef listLte_vt+  (a:vt0p, n:int) = [k:nat | k <= n] list_vt(a, k)+vtypedef listGt_vt+  (a:vt0p, n:int) = [k:int | k > n] list_vt(a, k)+vtypedef listGte_vt+  (a:vt0p, n:int) = [k:int | k >= n] list_vt(a, k)+vtypedef listBtw_vt+  (a:vt0p, m:int, n:int) = [k:int | m <= k; k < n] list_vt(a, k)+vtypedef listBtwe_vt+  (a:vt0p, m:int, n:int) = [k:int | m <= k; k <= n] list_vt(a, k)+//+(* ****** ****** *)+//+datatype+stream_con(a:t@ype+) =+  | stream_nil of ((*void*))+  | stream_cons of (a, stream(a))+//+where stream (a:t@ype) = lazy (stream_con(a))+//+datavtype+stream_vt_con+  (a:vt@ype+) =+  | stream_vt_nil of ((*void*))+  | stream_vt_cons of (a, stream_vt(a))+//+where+stream_vt(a:vt@ype) = lazy_vt(stream_vt_con(a))+//+(* ****** ****** *)+//+datatype+// t@ype+: covariant+option_t0ype_bool_type+(+  a:t@ype+, bool+) = // option_t0ype_bool_type+  | Some(a, true) of (INV(a)) | None(a, false)+// end of [datatype]+stadef option = option_t0ype_bool_type+typedef Option(a:t0p) = [b:bool] option(a, b)+//+datavtype+// vt@ype+: covariant+option_vt0ype_bool_vtype+(+  a:vt@ype+, bool+) = // option_vt0ype_bool_vtype+  | Some_vt(a, true) of (INV(a)) | None_vt(a, false)+// end of [option_vt0ype_bool_vtype]+stadef option_vt = option_vt0ype_bool_vtype+vtypedef Option_vt(a:vt0p) = [b:bool] option_vt(a, b)+//+(* ****** ****** *)+//+praxi+opt_some{a:vt0p}+  (x: !INV(a) >> opt(a, true)):<prf> void+praxi+opt_unsome{a:vt0p}+  (x: !opt(INV(a), true) >> a):<prf> void+//+fun{a:vt0p}+opt_unsome_get(x: &opt(INV(a), true) >> a?): (a)+//+praxi+opt_none{a:vt0p}+  (x: !(a?) >> opt(a, false)):<prf> void+praxi+opt_unnone{a:vt0p}+  (x: !opt(INV(a), false) >> a?):<prf> void+//+praxi+opt_clear{a:t0p}+  {b:bool}(x: !opt(INV(a), b) >> a?):<prf> void+//+(* ****** ****** *)+//+dataprop+or_prop_prop_int_prop+(+  a0: prop+, a1: prop+, int+) = // or_prop_prop_int_prop+  | POR_l(a0, a1, 0) of (INV(a0))+  | POR_r(a0, a1, 1) of (INV(a1))+dataview+or_view_view_int_view+(+  a0: view+, a1: view+, int+) = // or_view_view_int_view+  | VOR_l(a0, a1, 0) of (INV(a0))+  | VOR_r(a0, a1, 1) of (INV(a1))+//+stadef por = or_prop_prop_int_prop+stadef vor = or_view_view_int_view+//+dataprop+option_prop_bool_prop+(+  a:prop+, bool+) = // option_prop_bool_prop+  | Some_p (a, true) of (INV(a)) | None_p (a, false)+// end of [option_prop_bool_prop]+stadef option_p = option_prop_bool_prop+//+dataview+option_view_bool_view+  (a:view+, bool) =+  | Some_v (a, true) of (INV(a)) | None_v (a, false)+// end of [option_view_bool_view]+stadef option_v = option_view_bool_view+//+(* ****** ****** *)+//+absvt@ype+arrayopt(a:vt0p, n:int, b:bool) = array(a, n)+//+praxi+arrayopt_some+  {a:vt0p}{n:int}+  (A: &array(a, n) >> arrayopt(a, n, true)): void+praxi+arrayopt_none+  {a:vt0p}{n:int}+  (A: &array(a?, n) >> arrayopt(a, n, false)): void+praxi+arrayopt_unsome+  {a:vt0p}{n:int}+  (A: &arrayopt(a, n, true) >> array(a, n)): void+praxi+arrayopt_unnone+  {a:vt0p}{n:int}+  (A: &arrayopt(a, n, false) >> array(a?, n)): void+//+(* ****** ****** *)++absvtype+argv_int_vtype (n:int) = ptr+stadef argv = argv_int_vtype++(*+[argv_takeout_strarr] is declared in prelude/SATS/extern.sats+[argv_takeout_parrnull] is declared in prelude/SATS/extern.sats+*)++(* ****** ****** *)++praxi+lemma_argv_param+  {n:int}(argv: !argv(n)): [n >= 0] void+// end of [praxi]++(* ****** ****** *)+//+fun+argv_get_at{n:int}+  (argv: !argv(n), i: natLt(n)):<> string = "mac#%"+fun+argv_set_at{n:int}+  (argv: !argv(n), i: natLt(n), x: string):<!wrt> void = "mac#%"+//+overload [] with argv_get_at+overload [] with argv_set_at+//+(* ****** ****** *)+//+fun{}+listize_argc_argv+  {n:int}+  (argc: int(n), argv: !argv(n)): list_vt(string, n)+//+(* ****** ****** *)+//+symintr main0+//+fun+main_void_0+(+  (*void*)+) : void = "ext#mainats_void_0"+fun+main_argc_argv_0+  {n:int | n >= 1}+  (argc: int n, argv: !argv(n)): void = "ext#mainats_argc_argv_0"+//+overload main0 with main_void_0+overload main0 with main_argc_argv_0+//+(* ****** ****** *)+//+symintr main+//+fun+main_void_int+(+  (*void*)+) : int = "ext#mainats_void_int"+fun+main_argc_argv_int+  {n:int | n >= 1}+  (argc: int n, argv: !argv(n)): int = "ext#mainats_argc_argv_int"+fun+main_argc_argv_envp_int+  {n:int | n >= 1}+  (argc: int n, argv: !argv n, envp: ptr): int = "ext#mainats_argc_argv_envp_int"+//+overload main with main_void_int+overload main with main_argc_argv_int+overload main with main_argc_argv_envp_int+//+(* ****** ****** *)+//+fun+exit(ecode: int):<!exn> {a:t0p}(a) = "mac#%"+fun+exit_errmsg+  (ecode: int, msg: string):<!exn> {a:t0p}(a) = "mac#%"+//+(*+fun exit_fprintf{ts:types}+(+  ecode: int, out: FILEref, fmt: printf_c ts, args: ts+) :<!exn> {a:vt0p}(a) = "mac#%" // end of [exit_fprintf]+*)+//+(* *****p* ****** *)+//+fun+exit_void+  (ecode: int):<!exn> void = "mac#%"+fun+exit_errmsg_void+  (ecode: int, msg: string):<!exn> void = "mac#%"+//+(* ****** ****** *)+//+fun+assert_bool0+  (x: bool):<!exn> void = "mac#%"+fun+assert_bool1+  {b:bool} (x: bool (b)):<!exn> [b] void = "mac#%"+//+overload assert with assert_bool0 of 0+overload assert with assert_bool1 of 10+//+(* ****** ****** *)+//+fun{}+assertexn_bool0 (x: bool):<!exn> void+fun{}+assertexn_bool1 {b:bool} (x: bool (b)):<!exn> [b] void+//+symintr assertexn+overload assertexn with assertexn_bool0 of 0+overload assertexn with assertexn_bool1 of 10+//+(* ****** ****** *)+//+fun+assert_errmsg_bool0+  (x: bool, msg: string):<!exn> void = "mac#%"+fun+assert_errmsg_bool1+  {b:bool} (x: bool b, msg: string):<!exn> [b] void = "mac#%"+//+symintr assert_errmsg+overload assert_errmsg with assert_errmsg_bool0 of 0+overload assert_errmsg with assert_errmsg_bool1 of 10+//+(* ****** ****** *)+//+fun+assert_errmsg2_bool0+  (x: bool, msg1: string, msg2: string):<!exn> void = "mac#%"+fun+assert_errmsg2_bool1{b:bool}+  (x: bool b, msg1: string, msg2: string):<!exn> [b] void = "mac#%"+//+symintr assert_errmsg2+overload assert_errmsg2 with assert_errmsg2_bool0 of 0+overload assert_errmsg2 with assert_errmsg2_bool1 of 10+//+(* ****** ****** *)+//+datasort+file_mode =+  | file_mode_r (* read *)+  | file_mode_w (* write *)+  | file_mode_rw (* read and write *)+// end of [file_mode]+//+(* ****** ****** *)++local+//+stadef r() = file_mode_r()+stadef w() = file_mode_w()+stadef rw() = file_mode_rw()+//+in (* in-of-local *)++(* ****** ****** *)++abstype+file_mode (file_mode) = string+typedef+file_mode = [fm:file_mode] file_mode (fm)++(* ****** ****** *)++sortdef fmode = file_mode+typedef fmode (fm:fmode) = file_mode (fm)+typedef fmode = file_mode++(* ****** ****** *)++dataprop+file_mode_lte+  (fmode, fmode) =+//+  | {m:fmode} file_mode_lte_refl (m, m)+//+  | {m1,m2,m3:fmode}+    file_mode_lte_tran (m1, m3) of+    (file_mode_lte(m1, m2), file_mode_lte(m2, m3))+//+  | {m:fmode} file_mode_lte_rw_r(rw(), r()) of ()+  | {m:fmode} file_mode_lte_rw_w(rw(), w()) of ()+// end of [file_mode_lte]++(* ****** ****** *)+//+prval+file_mode_lte_r_r+  : file_mode_lte(r(), r()) // impled in [filebas_prf.dats]+prval+file_mode_lte_w_w+  : file_mode_lte(w(), w()) // impled in [filebas_prf.dats]+prval+file_mode_lte_rw_rw+  : file_mode_lte(rw(), rw()) // impled in [filebas_prf.dats]+//+(* ****** ****** *)++end // end of [local]++(* ****** ****** *)++abstype FILEref_type = ptr+typedef FILEref = FILEref_type++(* ****** ****** *)+//+typedef+print_type(a: t0p) = (a) -> void+typedef+prerr_type(a: t0p) = (a) -> void+typedef+fprint_type(a: t0p) = (FILEref, a) -> void+//+typedef+print_vtype(a: vt0p) = (!a) -> void+typedef+prerr_vtype(a: vt0p) = (!a) -> void+typedef+fprint_vtype(a: vt0p) = (FILEref, !a) -> void+//+(* ****** ****** *)++(*+fun print_void(x: void): void = "mac#%"+*)++(* ****** ****** *)++fun print_newline((*void*)): void = "mac#%"+fun prerr_newline((*void*)): void = "mac#%"+fun fprint_newline(out: FILEref): void = "mac#%"++(* ****** ****** *)++#if VERBOSE_PRELUDE #then+#print "Loading [basics_dyn.sats] finishes!\n"+#endif // end of [VERBOSE_PRELUDE]++(* ****** ****** *)++(* end of [basics_dyn.sats] *)

@@ -0,0 +1,148 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2013 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+//+// Author of the file:+// Hongwei Xi (gmhwxiATgmailDOTcom)+// Start Time: July, 2012+//+(* ****** ****** *)+#include "prelude/params.hats"++(* ****** ****** *)++#if VERBOSE_PRELUDE #then+#print "Loading [basics_gen.sats] starts!\n"+#endif // end of [VERBOSE_PRELUDE]+(* ****** ****** *)+//+fun {a:t0p} gidentity (x : INV(a)) :<> a++//+fun {a:vt0p} gidentity_vt (x : INV(a)) :<> a++//+(* ****** ****** *)+//+fun {a:vt0p} gcopy_val (x : !INV(a)) :<!wrt> a++//+fun {a:vt0p} gcopy_ref (x : &INV(a)) :<!wrt> a++//+(* ****** ****** *)+//+fun {a:vt0p} gfree_val (x : INV(a)) :<!wrt> void++//+(*+fun+{a:vt0p}+gfree_ref (x: &INV(a) >> a?):<!wrt> void+*)+//+(* ****** ****** *)+fun {a:vt0p} ginit_ref (x : &a? >> a) :<!wrt> void++(* ****** ****** *)+fun {a:vt0p} gclear_ref (x : &a >> a?) :<!wrt> void++(* ****** ****** *)+//+fun {a:t0p} gequal_val_val (x : a, y : a) :<> bool++//+fun {a:vt0p} gequal_ref_ref (x : &INV(a), y : &a) :<> bool++//+(* ****** ****** *)+fun {a:t0p} tostring_val (x : a) :<> string++fun {a:vt0p} tostring_ref (x : &INV(a)) :<> string++(* ****** ****** *)+fun {a:t0p} tostrptr_val (x : a) :<!wrt> Strptr1++fun {a:vt0p} tostrptr_ref (x : &INV(a)) :<!wrt> Strptr1++(* ****** ****** *)+(*+//+fun{a:t0p}+print_val (x: a): void // = fprint_val (stdout_ref, x)+fun{a:t0p}+prerr_val (x: a): void // = fprint_val (stderr_ref, x)+//+fun{a:vt0p}+print_ref (x: &INV(a)): void // = fprint_ref (stdout_ref, x)+fun{a:vt0p}+prerr_ref (x: &INV(a)): void // = fprint_ref (stderr_ref, x)+//+*)+(* ****** ****** *)+//+fun {a:t0p} fprint_val (out : FILEref, x : a) : void++fun {a:vt0p} fprint_ref (out : FILEref, x : &INV(a)) : void++//+(* ****** ****** *)+//+fun {src:vt0p}{elt:vt0p} streamize_val (source : src) : stream_vt(elt)++//+(* ****** ****** *)+//+fun {a:t0p} print_stamped_t (stamped_t(a)) : void++fun {a:t0p} prerr_stamped_t (stamped_t(a)) : void++fun {a:t0p} fprint_stamped_t (out : FILEref, x : stamped_t(a)) : void++(*+//+// HX-2017-12-09:+// This one does not seem to be so useful+//+fun+{a:vt0p}+fprint_stamped_vt(out: FILEref, x: &stamped_vt(a)): void+*)+//+overload print with print_stamped_t++overload prerr with prerr_stamped_t++overload fprint with fprint_stamped_t++//+(* ****** ****** *)++#if VERBOSE_PRELUDE #then+#print "Loading [basics_gen.sats] finishes!\n"+#endif // end of [VERBOSE_PRELUDE]+(* ****** ****** *)+(* end of [basics_gen.sats] *)

@@ -0,0 +1,175 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2013 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)+//+// Author of the file:+// Hongwei Xi (gmhwxiATgmailDOTcom)+// Start Time: July, 2012+//+(* ****** ****** *)++#include "prelude/params.hats"++(* ****** ****** *)++#if VERBOSE_PRELUDE #then+#print "Loading [basics_gen.sats] starts!\n"+#endif // end of [VERBOSE_PRELUDE]++(* ****** ****** *)+//+fun+{a:t0p}+gidentity (x: INV(a)):<> a+//+fun+{a:vt0p}+gidentity_vt (x: INV(a)):<> a+//+(* ****** ****** *)+//+fun+{a:vt0p}+gcopy_val (x: !INV(a)):<!wrt> a+//+fun+{a:vt0p}+gcopy_ref (x: &INV(a)):<!wrt> a+//+(* ****** ****** *)+//+fun+{a:vt0p}+gfree_val (x: INV(a)):<!wrt> void+//+(*+fun+{a:vt0p}+gfree_ref (x: &INV(a) >> a?):<!wrt> void+*)+//+(* ****** ****** *)++fun+{a:vt0p}+ginit_ref (x: &a? >> a):<!wrt> void++(* ****** ****** *)++fun+{a:vt0p}+gclear_ref (x: &a >> a?):<!wrt> void++(* ****** ****** *)+//+fun+{a:t0p}+gequal_val_val (x: a, y: a):<> bool+//+fun+{a:vt0p}+gequal_ref_ref (x: &INV(a), y: &a):<> bool+//+(* ****** ****** *)++fun{a:t0p}+tostring_val (x: a):<> string+fun{a:vt0p}+tostring_ref (x: &INV(a)):<> string++(* ****** ****** *)++fun{a:t0p}+tostrptr_val (x: a):<!wrt> Strptr1+fun{a:vt0p}+tostrptr_ref (x: &INV(a)):<!wrt> Strptr1++(* ****** ****** *)++(*+//+fun{a:t0p}+print_val (x: a): void // = fprint_val (stdout_ref, x)+fun{a:t0p}+prerr_val (x: a): void // = fprint_val (stderr_ref, x)+//+fun{a:vt0p}+print_ref (x: &INV(a)): void // = fprint_ref (stdout_ref, x)+fun{a:vt0p}+prerr_ref (x: &INV(a)): void // = fprint_ref (stderr_ref, x)+//+*)++(* ****** ****** *)+//+fun{a:t0p}+fprint_val(out: FILEref, x: a): void+fun{a:vt0p}+fprint_ref(out: FILEref, x: &INV(a)): void+//+(* ****** ****** *)+//+fun+{src:vt0p}+{elt:vt0p}+streamize_val(source: src): stream_vt(elt)+//+(* ****** ****** *)+//+fun+{a:t0p}+print_stamped_t(stamped_t(a)): void+fun+{a:t0p}+prerr_stamped_t(stamped_t(a)): void+fun+{a:t0p}+fprint_stamped_t(out: FILEref, x: stamped_t(a)): void+(*+//+// HX-2017-12-09:+// This one does not seem to be so useful+//+fun+{a:vt0p}+fprint_stamped_vt(out: FILEref, x: &stamped_vt(a)): void+*)+//+overload print with print_stamped_t+overload prerr with prerr_stamped_t+overload fprint with fprint_stamped_t+//+(* ****** ****** *)++#if VERBOSE_PRELUDE #then+#print "Loading [basics_gen.sats] finishes!\n"+#endif // end of [VERBOSE_PRELUDE]++(* ****** ****** *)++(* end of [basics_gen.sats] *)

@@ -0,0 +1,63 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/DATS/CODEGEN/bool.atxt+** Time of generation: Thu Jan 11 11:00:12 2018+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: Feburary, 2012 *)+(* ****** ****** *)+#define ATS_DYNLOADFLAG 0 // no dynloading at run-time++(* ****** ****** *)+(*+//+// HX: see CATS/bool.cats+//+implement+bool2string+  (b) = if b then "true" else "false"+// end of [bool2string]+*)+(* ****** ****** *)+(*+//+// HX: see CATS/bool.cats+//+implement+fprint_bool (out, x) =+  fprint_string (out, bool2string (x))+// end of [fprint_bool]+*)+implement fprint_val<bool> =+  fprint_bool++(* ****** ****** *)+(* end of [bool.dats] *)

@@ -0,0 +1,123 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/checkast.atxt+** Time of generation: Thu Jan 11 11:00:06 2018+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: gmhwxiATgmailDOTcom *)+(* Start time: December, 2013 *)+(* ****** ****** *)+#define ATS_PACKNAME"ATSLIB.prelude.checkast"++(* ****** ****** *)+sortdef t0p = t@ype and vt0p = vt@ype++(* ****** ****** *)+//+fun checkast_charNZ(c : char, msg : RD(string)) : charNZ++//+(* ****** ****** *)+fun {tk:tk} checkast_gintLt {i:int} ( x : g0int(tk)+                                    , i : int(i)+                                    , msg : RD(string)+                                    ) : g1intLt(tk, i)++fun {tk:tk} checkast_gintLte {i:int} ( x : g0int(tk)+                                     , i : int(i)+                                     , msg : RD(string)+                                     ) : g1intLte(tk, i)++fun {tk:tk} checkast_gintGt {i:int} ( x : g0int(tk)+                                    , i : int(i)+                                    , msg : RD(string)+                                    ) : g1intGt(tk, i)++fun {tk:tk} checkast_gintGte {i:int} ( x : g0int(tk)+                                     , i : int(i)+                                     , msg : RD(string)+                                     ) : g1intGte(tk, i)++fun {tk:tk} checkast_gintBtw { i, j : int } ( x : g0int(tk)+                                            , i : int(i)+                                            , j : int(j)+                                            , msg : RD(string)+                                            ) : g1intBtw(tk, i, j)++fun {tk:tk} checkast_gintBtwe { i, j : int } ( x : g0int(tk)+                                             , i : int(i)+                                             , j : int(j)+                                             , msg : RD(string)+                                             ) : g1intBtwe(tk, i, j)++(* ****** ****** *)+macdef ckastloc_charNZ(x) = checkast_charNZ(,(x), $mylocation)++(* ****** ****** *)+macdef ckastloc_gintLt(i, x) = checkast_gintLt(,(x), ,(i), $mylocation)++macdef ckastloc_gintLte(i, x) = checkast_gintLte( ,(x)+                                                , ,(i)+                                                , $mylocation+                                                )++macdef ckastloc_gintGt(i, x) = checkast_gintGt(,(x), ,(i), $mylocation)++macdef ckastloc_gintGte(i, x) = checkast_gintGte( ,(x)+                                                , ,(i)+                                                , $mylocation+                                                )++macdef ckastloc_gintBtw(j, i, x) = checkast_gintBtw( ,(x)+                                                   , ,(i)+                                                   , ,(j)+                                                   , $mylocation+                                                   )++macdef ckastloc_gintBtwe(j, i, x) = checkast_gintBtwe( ,(x)+                                                     , ,(i)+                                                     , ,(j)+                                                     , $mylocation+                                                     )++(* ****** ****** *)+fun checkast_Ptr1(x : ptr, msg : RD(string)) : Ptr1++(* ****** ****** *)+macdef ckastloc_Ptr1(x) = checkast_Ptr1(,(x), $mylocation)++(* ****** ****** *)+fun checkast_Strptr1(x : Strptr0, msg : RD(string)) : Strptr1++(* ****** ****** *)+macdef ckastloc_Strptr1(x) = checkast_Strptr1(,(x), $mylocation)++(* ****** ****** *)+(* end of [checkast.sats] *)

@@ -0,0 +1,120 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)++(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/checkast.atxt+** Time of generation: Thu Jan 11 11:00:06 2018+*)++(* ****** ****** *)++(* Author: Hongwei Xi *)+(* Authoremail: gmhwxiATgmailDOTcom *)+(* Start time: December, 2013 *)++(* ****** ****** *)++#define+ATS_PACKNAME "ATSLIB.prelude.checkast"++(* ****** ****** *)++sortdef t0p = t@ype and vt0p = viewt@ype++(* ****** ****** *)+//+fun{}+checkast_charNZ+  (c: char, msg: RD(string)): charNZ+//+(* ****** ****** *)++fun{tk:tk}+checkast_gintLt{i:int}+  (x: g0int(tk), i: int i, msg: RD(string)): g1intLt(tk, i)+fun{tk:tk}+checkast_gintLte{i:int}+  (x: g0int(tk), i: int i, msg: RD(string)): g1intLte(tk, i)+fun{tk:tk}+checkast_gintGt{i:int}+  (x: g0int(tk), i: int i, msg: RD(string)): g1intGt(tk, i)+fun{tk:tk}+checkast_gintGte{i:int}+  (x: g0int(tk), i: int i, msg: RD(string)): g1intGte(tk, i)+fun{tk:tk}+checkast_gintBtw{i,j:int}+  (x: g0int(tk), i: int i, j: int j, msg: RD(string)): g1intBtw(tk, i, j)+fun{tk:tk}+checkast_gintBtwe{i,j:int}+  (x: g0int(tk), i: int i, j: int j, msg: RD(string)): g1intBtwe(tk, i, j)++(* ****** ****** *)++macdef+ckastloc_charNZ(x) = checkast_charNZ(,(x), $mylocation)++(* ****** ****** *)++macdef+ckastloc_gintLt(x, i) = checkast_gintLt(,(x), ,(i), $mylocation)+macdef+ckastloc_gintLte(x, i) = checkast_gintLte(,(x), ,(i), $mylocation)+macdef+ckastloc_gintGt(x, i) = checkast_gintGt(,(x), ,(i), $mylocation)+macdef+ckastloc_gintGte(x, i) = checkast_gintGte(,(x), ,(i), $mylocation)+macdef+ckastloc_gintBtw(x, i, j) = checkast_gintBtw(,(x), ,(i), ,(j), $mylocation)+macdef+ckastloc_gintBtwe(x, i, j) = checkast_gintBtwe(,(x), ,(i), ,(j), $mylocation)++(* ****** ****** *)++fun{}+checkast_Ptr1(x: ptr, msg: RD(string)): Ptr1++(* ****** ****** *)++macdef+ckastloc_Ptr1(x) = checkast_Ptr1(,(x), $mylocation)++(* ****** ****** *)++fun{}+checkast_Strptr1(x: Strptr0, msg: RD(string)): Strptr1++(* ****** ****** *)++macdef+ckastloc_Strptr1(x) = checkast_Strptr1(,(x), $mylocation)++(* ****** ****** *)++(* end of [checkast.sats] *)

@@ -0,0 +1,360 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/filebas.atxt+** Time of generation: Thu Jan 11 11:00:06 2018+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: February, 2012 *)+(* ****** ****** *)+sortdef t0p = t@ype and vt0p = vt@ype++(* ****** ****** *)+#define NSH (x) x // for commenting: no sharing+#define SHR (x) x // for commenting: it is shared++(* ****** ****** *)+val stdin_ref: FILEref = "mac#%FILE_stdin"+val stdout_ref: FILEref = "mac#%FILE_stdout"+val stderr_ref: FILEref = "mac#%FILE_stderr"++(* ****** ****** *)+fun dirsep_get() :<> charNZ++fun dirsep_gets() :<> string++fun dirname_self() :<> string++fun dirname_parent() :<> string++(* ****** ****** *)+fun filename_get_ext(name : string) :<> vStrptr0++fun filename_test_ext(name : string, ext : string) :<> bool++(* ****** ****** *)+fun filename_get_base(name : string) :<> vStrptr1++fun filename_test_base(name : string, base : string) :<> bool++(* ****** ****** *)+//+val file_mode_r: file_mode(file_mode_r()) = "mac#%"++// = "r"+val file_mode_rr: file_mode(file_mode_rw()) = "mac#%"++// = "r+"+//+val file_mode_w: file_mode(file_mode_w()) = "mac#%"++// = "w"+val file_mode_ww: file_mode(file_mode_rw()) = "mac#%"++// = "w+"+//+val file_mode_a: file_mode(file_mode_rw()) = "mac#%"++// = "a"+val file_mode_aa: file_mode(file_mode_rw()) = "mac#%"++// = "a+"+//+(* ****** ****** *)+//+(*+** HX: [stat] is called+*)+fun test_file_exists(path : NSH(string)) : bool =+  "mac#%"++//+(* ****** ****** *)+//+// HX-2011-02-16:+// [stat] is called to obtain the mode of a given file+// for [f] to be applied to it.+//+fun test_file_mode(path : NSH(string)) : int++//+fun test_file_mode$pred(mode : uint) : bool++//+fun test_file_mode_fun(path : NSH(string), f : uint -> bool) : int =+  "mac#%"++//+// HX: [stat] is called // ~1/0/1: error/false/true+//+fun test_file_isblk(path : NSH(string)) : int =+  "mac#%"++fun test_file_ischr(path : NSH(string)) : int =+  "mac#%"++fun test_file_isdir(path : NSH(string)) : int =+  "mac#%"++fun test_file_isfifo(path : NSH(string)) : int =+  "mac#%"++fun test_file_isreg(path : NSH(string)) : int =+  "mac#%"++//+// HX: [lstat] is called // ~1/0/1: error/false/true+//+fun test_file_islnk(path : NSH(string)) : int =+  "mac#%"++//+(* ****** ****** *)+//+fun fileref_open_exn(path : NSH(string), file_mode) : FILEref =+  "mac#%"++// end of [fileref_open_exn]+//+fun fileref_open_opt(path : NSH(string), file_mode) : Option_vt(FILEref)++// end of [fileref_open_opt]+//+(* ****** ****** *)+//+fun fileref_close(fil : FILEref) : void =+  "mac#%"++//+(* ****** ****** *)+//+fun fileref_flush(fil : FILEref) : void =+  "mac#%"++//+(* ****** ****** *)+//+// HX: error indication: EOF+//+fun fileref_getc(input : FILEref) : int =+  "mac#%"++//+(* ****** ****** *)+//+// HX: no error reporting+//+fun fileref_putc_int(out : FILEref, c : int) : void =+  "mac#%"++//+fun fileref_putc_char(out : FILEref, c : char) : void =+  "mac#%"++//+symintr fileref_putc++overload fileref_putc with fileref_putc_int++overload fileref_putc with fileref_putc_char++//+(* ****** ****** *)+//+// HX: no error reporting+//+fun fileref_puts(out : FILEref, NSH(string)) : void =+  "mac#%"++//+(* ****** ****** *)+//+fun fileref_is_eof(inp : FILEref) : bool =+  "mac#%"++//+macdef fileref_isnot_eof(inp) = ~fileref_is_eof(,(inp))++//+(* ****** ****** *)+typedef fileref_load_type(a: t@ype) = (FILEref, &a? >> opt(a, b)) -<fun1> #[b:bool] bool(b)++// end of [fileref_load_type]+//+fun {a:t0p} fileref_load  : fileref_load_type(a)++//+fun fileref_load_int : fileref_load_type(int) =+  "mac#%"++fun fileref_load_lint : fileref_load_type(lint) =+  "mac#%"++fun fileref_load_uint : fileref_load_type(uint) =+  "mac#%"++fun fileref_load_ulint : fileref_load_type(ulint) =+  "mac#%"++//+fun fileref_load_float : fileref_load_type(float) =+  "mac#%"++fun fileref_load_double : fileref_load_type(double) =+  "mac#%"++//+(* ****** ****** *)+fun {a:t0p} fileref_get_optval (inp : FILEref) : Option_vt(a)++// end of [fileref_get_optval]+fun {a:t0p} fileref_get_exnmsg (inp : FILEref, msg : NSH(string)) : a++// end of [fileref_get_exnmsg]+macdef fileref_get_exnloc(inp) = fileref_get_exnmsg(,(inp), $mylocation)++// end of [fileref_get_exnloc]+(* ****** ****** *)+typedef charlst = List0(char)++vtypedef charlst_vt = List0_vt(char)++(* ****** ****** *)+//+fun fileref_get_line_charlst(inp : FILEref) : charlst_vt++//+(* ****** ****** *)+//+(*+** HX: only for files of "tiny" size+*)+fun fileref_get_lines_charlstlst(inp : FILEref) : List0_vt(charlst_vt)++//+(* ****** ****** *)+//+(*+** HX: for handling files of "tiny" size+*)+fun fileref_get_file_charlst(inp : FILEref) : List0_vt(char)++fun fileref_get2_file_charlst(inp : FILEref, n : int) : List0_vt(char)++//+(* ****** ****** *)+//+//+fun fileref_put_string(out : FILEref, cs : NSH(string)) : void++fun fileref_put_charlst(inp : FILEref, cs : NSH(List(char))) : void++//+(* ****** ****** *)+//+//+// HX-2013-05:+// these functions are based on [fgets];+// they should only be applied to files containing+// no occurrences of the NUL character ('\000').+//+fun fileref_get_line_string(inp : FILEref) : Strptr1++//+fun fileref_get_line_string_main( inp : FILEref+                                , nchar : &int? >> int(n)+                                ) : #[n:nat] strnptr(n)++// end-of-function+fun fileref_get_line_string$bufsize() : intGte(1)++//+fun fileref_get_lines_stringlst(inp : FILEref) : List0_vt(Strptr1)++//+(* ****** ****** *)+//+fun fileref_get_file_string(inp : FILEref) : Strptr1++fun fileref_get_file_string$bufsize() : intGte(1)++//+(* ****** ****** *)+//+fun fileref_get_word(inp : FILEref) : Strptr0++fun fileref_get_word$isalpha(c0 : charNZ) : bool++//+(* ****** ****** *)+//+fun fileref_foreach(inp : FILEref) : void++fun {env:vt0p} fileref_foreach_env (inp : FILEref, env : &(env) >> _) :+  void++//+fun fileref_foreach$bufsize() : sizeGte(1)++fun {env:vt0p} fileref_foreach$fwork (c : char, env : &(env) >> _) :+  void++fun {env:vt0p} fileref_foreach$fworkv {n:int} ( arrayref(char,n)+                                              , size_t(n)+                                              , &(env) >> _+                                              ) : void++//+(* ****** ****** *)+//+fun streamize_fileref_char(inp : FILEref) : stream_vt(char)++fun streamize_fileref_line(inp : FILEref) : stream_vt(Strptr1)++//+(* ****** ****** *)+//+absvtype FILEptr1_vtype = ptr++vtypedef FILEptr1 = FILEptr1_vtype++//+fun streamize_fileptr_char(inp : FILEptr1) : stream_vt(char)++fun streamize_fileptr_line(inp : FILEptr1) : stream_vt(Strptr1)++//+(* ****** ****** *)+//+fun streamize_dirname_fname(dir : NSH(string)) : stream_vt(Strptr1)++//+(* ****** ****** *)+(* end of [filebas.sats] *)

@@ -0,0 +1,358 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)++(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/filebas.atxt+** Time of generation: Thu Jan 11 11:00:06 2018+*)++(* ****** ****** *)++(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: February, 2012 *)++(* ****** ****** *)++sortdef t0p = t@ype and vt0p = viewt@ype++(* ****** ****** *)++#define NSH (x) x // for commenting: no sharing+#define SHR (x) x // for commenting: it is shared++(* ****** ****** *)++val stdin_ref : FILEref = "mac#%FILE_stdin"+val stdout_ref : FILEref = "mac#%FILE_stdout"+val stderr_ref : FILEref = "mac#%FILE_stderr"++(* ****** ****** *)++fun{} dirsep_get ():<> charNZ+fun{} dirsep_gets ():<> string+fun{} dirname_self ():<> string+fun{} dirname_parent ():<> string++(* ****** ****** *)++fun{}+filename_get_ext(name: string):<> vStrptr0+fun{}+filename_test_ext(name: string, ext: string):<> bool++(* ****** ****** *)++fun{}+filename_get_base (name: string):<> vStrptr1+fun{}+filename_test_base (name: string, base: string):<> bool++(* ****** ****** *)+//+val file_mode_r+  : file_mode(file_mode_r()) = "mac#%" // = "r"+val file_mode_rr+  : file_mode(file_mode_rw()) = "mac#%" // = "r+"+//+val file_mode_w+  : file_mode(file_mode_w()) = "mac#%" // = "w"+val file_mode_ww+  : file_mode(file_mode_rw()) = "mac#%" // = "w+"+//+val file_mode_a+  : file_mode(file_mode_rw()) = "mac#%" // = "a"+val file_mode_aa+  : file_mode(file_mode_rw()) = "mac#%" // = "a+"+//+(* ****** ****** *)+//+(*+** HX: [stat] is called+*)+fun+test_file_exists+  (path: NSH(string)): bool = "mac#%"+//+(* ****** ****** *)+//+// HX-2011-02-16:+// [stat] is called to obtain the mode of a given file+// for [f] to be applied to it.+//+fun{}+test_file_mode+  (path: NSH(string)): int+//+fun{}+test_file_mode$pred (mode: uint): bool+//+fun+test_file_mode_fun+  (path: NSH(string), f: uint -> bool): int = "mac#%"+//+// HX: [stat] is called // ~1/0/1: error/false/true+//+fun+test_file_isblk(path: NSH(string)): int = "mac#%"+fun+test_file_ischr(path: NSH(string)): int = "mac#%"+fun+test_file_isdir(path: NSH(string)): int = "mac#%"+fun+test_file_isfifo(path: NSH(string)): int = "mac#%"+fun+test_file_isreg(path: NSH(string)): int = "mac#%"+//+// HX: [lstat] is called // ~1/0/1: error/false/true+//+fun+test_file_islnk(path: NSH(string)): int = "mac#%"+//+(* ****** ****** *)+//+fun+fileref_open_exn+  (path: NSH(string), file_mode): FILEref = "mac#%"+// end of [fileref_open_exn]+//+fun{}+fileref_open_opt+  (path: NSH(string), file_mode): Option_vt(FILEref)+// end of [fileref_open_opt]+//+(* ****** ****** *)+//+fun+fileref_close(fil: FILEref): void = "mac#%"+//+(* ****** ****** *)+//+fun+fileref_flush(fil: FILEref): void = "mac#%"+//+(* ****** ****** *)+//+// HX: error indication: EOF+//+fun+fileref_getc(input: FILEref): int = "mac#%"+//+(* ****** ****** *)+//+// HX: no error reporting+//+fun+fileref_putc_int+  (out: FILEref, c: int): void = "mac#%"+//+fun+fileref_putc_char+  (out: FILEref, c: char): void = "mac#%"+//+symintr fileref_putc+overload fileref_putc with fileref_putc_int+overload fileref_putc with fileref_putc_char+//+(* ****** ****** *)+//+// HX: no error reporting+//+fun+fileref_puts+  (out: FILEref, NSH(string)): void = "mac#%"+//+(* ****** ****** *)+//+fun+fileref_is_eof(inp: FILEref): bool = "mac#%"+//+macdef+fileref_isnot_eof(inp) = ~fileref_is_eof(,(inp))+//+(* ****** ****** *)++typedef+fileref_load_type(a:t@ype) =+  (FILEref, &a? >> opt(a, b)) -<fun1> #[b:bool] bool(b)+// end of [fileref_load_type]+//+fun{a:t0p}+fileref_load : fileref_load_type (a)+//+fun+fileref_load_int : fileref_load_type(int) = "mac#%"+fun+fileref_load_lint : fileref_load_type(lint) = "mac#%"+fun+fileref_load_uint : fileref_load_type(uint) = "mac#%"+fun+fileref_load_ulint : fileref_load_type(ulint) = "mac#%"+//+fun+fileref_load_float : fileref_load_type(float) = "mac#%"+fun+fileref_load_double : fileref_load_type(double) = "mac#%"+//+(* ****** ****** *)++fun{a:t0p}+fileref_get_optval+  (inp: FILEref): Option_vt(a)+// end of [fileref_get_optval]++fun{+a:t0p+} fileref_get_exnmsg+  (inp: FILEref, msg: NSH(string)): a+// end of [fileref_get_exnmsg]++macdef+fileref_get_exnloc+  (inp) = fileref_get_exnmsg(,(inp), $mylocation)+// end of [fileref_get_exnloc]++(* ****** ****** *)++typedef charlst = List0(char)+vtypedef charlst_vt = List0_vt(char)++(* ****** ****** *)+//+fun+fileref_get_line_charlst(inp: FILEref): charlst_vt+//+(* ****** ****** *)+//+(*+** HX: only for files of "tiny" size+*)+fun+fileref_get_lines_charlstlst(inp: FILEref): List0_vt(charlst_vt)+//+(* ****** ****** *)+//+(*+** HX: for handling files of "tiny" size+*)+fun+fileref_get_file_charlst(inp: FILEref): List0_vt(char)+fun+fileref_get2_file_charlst(inp: FILEref, n: int): List0_vt(char)+//+(* ****** ****** *)+//+//+fun+fileref_put_string+  (out: FILEref, cs: NSH(string)): void+fun+fileref_put_charlst+  (inp: FILEref, cs: NSH(List(char))): void+//+(* ****** ****** *)+//+//+// HX-2013-05:+// these functions are based on [fgets];+// they should only be applied to files containing+// no occurrences of the NUL character ('\000').+//+fun{}+fileref_get_line_string(inp: FILEref): Strptr1+//+fun{}+fileref_get_line_string_main+(+  inp: FILEref, nchar: &int? >> int(n)+) : #[n:nat] strnptr(n) // end-of-function+fun{}+fileref_get_line_string$bufsize((*void*)): intGte(1)+//+fun{}+fileref_get_lines_stringlst(inp: FILEref): List0_vt(Strptr1)+//+(* ****** ****** *)+//+fun{}+fileref_get_file_string(inp: FILEref): Strptr1+fun{}+fileref_get_file_string$bufsize((*void*)): intGte(1)+//+(* ****** ****** *)+//+fun{}+fileref_get_word(inp: FILEref): Strptr0+fun{}+fileref_get_word$isalpha(c0: charNZ): bool+//+(* ****** ****** *)+//+fun{}+fileref_foreach(inp: FILEref): void+fun{+env:vt0p+} fileref_foreach_env(inp: FILEref, env: &(env) >> _): void+//+fun{}+fileref_foreach$bufsize((*void*)): sizeGte(1)+fun{+env:vt0p+} fileref_foreach$fwork(c: char, env: &(env) >> _): void+fun{+env:vt0p+} fileref_foreach$fworkv+  {n:int} (arrayref(char, n), size_t(n), &(env) >> _): void+//+(* ****** ****** *)+//+fun{}+streamize_fileref_char(inp: FILEref): stream_vt(char)+fun{}+streamize_fileref_line(inp: FILEref): stream_vt(Strptr1)+//+(* ****** ****** *)+//+absvtype FILEptr1_vtype = ptr+vtypedef FILEptr1 = FILEptr1_vtype+//+fun{}+streamize_fileptr_char(inp: FILEptr1): stream_vt(char)+fun{}+streamize_fileptr_line(inp: FILEptr1): stream_vt(Strptr1)+//+(* ****** ****** *)+//+fun{}+streamize_dirname_fname(dir: NSH(string)): stream_vt(Strptr1)+//+(* ****** ****** *)++(* end of [filebas.sats] *)

@@ -0,0 +1,128 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/gnumber.atxt+** Time of generation: Thu Jan 11 11:00:07 2018+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: September, 2011 *)+(* ****** ****** *)+(* Author: Brandon Barker *)+(* Authoremail: brandon.barker AT gmail DOT com *)+(* Start time: July, 2013 *)+(* ****** ****** *)+//+// HX: for unindexed gnumber types+//+(* ****** ****** *)+sortdef tk = tkind++(* ****** ****** *)+typedef SHR(a: type) = a++// for commenting purpose+typedef NSH(a: type) = a++// for commenting purpose+(* ****** ****** *)+abstype fprecision_prop(a1: t0p, a2: t0p)++propdef fprecision (a1 : t0p, a2 : t0p) = fprecision_prop(a1, a2)++praxi fprecision_float() : fprecision(float, float)++praxi fprecision_double() : fprecision(double, double)++praxi fprecision_ldouble() : fprecision(ldouble, ldouble)++(* ****** ****** *)+//+// HX: generic number operations+//+(* ****** ****** *)+//+//+fun {a:t0p} gnumber_int (x : int) :<> a++fun {a:t0p} gnumber_double (x : double) :<> a++//+(* ****** ****** *)+fun {a:t0p} gabs_val (x : a) :<> a++fun {a:t0p} gneg_val (x : a) :<> a++fun {a:t0p} gsucc_val (x : a) :<> a++fun {a:t0p} gpred_val (x : a) :<> a++fun {a:t0p} grecip_val (x : a) :<!exn> a++(* ****** ****** *)+fun {a:t0p} gadd_val_val (x : a, y : a) :<> a++fun {a:t0p} gsub_val_val (x : a, y : a) :<> a++fun {a:t0p} gmul_val_val (x : a, y : a) :<> a++fun {a:t0p} gdiv_val_val (x : a, y : a) :<!exn> a++fun {a:t0p} gmod_val_val (x : a, y : a) :<!exn> a++(* ****** ****** *)+//+fun {a:t0p} gadd_val_int (x : a, y : int) :<> a++fun {a:t0p} gsub_val_int (x : a, y : int) :<> a++//+fun {a:t0p} gmul_int_val (x : int, y : a) :<> a++fun {a:t0p} gmul_val_int (x : a, y : int) :<> a++//+fun {a:t0p} gdiv_int_val (x : int, y : a) :<!exn> a++fun {a:t0p} gdiv_val_int (x : a, y : int) :<!exn> a++fun {a:t0p} gmod_val_int (x : a, y : int) :<!exn> a++//+(* ****** ****** *)+fun {a:t0p} gsqrt_val (x : a) :<!exn> a++(* ****** ****** *)+fun {a:t0p} gconjugate_val (x : a) :<> a++(* ****** ****** *)+fun {a:t0p} gpow_int_val (n : intGte(0), x : a) :<> a++(* ****** ****** *)+(* end of [gnumber.sats] *)

@@ -0,0 +1,127 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)++(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/gnumber.atxt+** Time of generation: Thu Jan 11 11:00:07 2018+*)++(* ****** ****** *)++(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: September, 2011 *)++(* ****** ****** *)++(* Author: Brandon Barker *)+(* Authoremail: brandon.barker AT gmail DOT com *)+(* Start time: July, 2013 *)++(* ****** ****** *)+//+// HX: for unindexed gnumber types+//+(* ****** ****** *)++sortdef tk = tkind++(* ****** ****** *)++typedef SHR(a:type) = a // for commenting purpose+typedef NSH(a:type) = a // for commenting purpose++(* ****** ****** *)++abstype+fprecision_prop (a1:t0p, a2:t0p)+propdef+fprecision (a1:t0p, a2:t0p) = fprecision_prop (a1, a2)+praxi+fprecision_float (): fprecision (float, float)+praxi+fprecision_double (): fprecision (double, double)+praxi+fprecision_ldouble (): fprecision (ldouble, ldouble)++(* ****** ****** *)+//+// HX: generic number operations+//+(* ****** ****** *)+//++//+fun{a:t0p} gnumber_int (x: int):<> a+fun{a:t0p} gnumber_double (x: double):<> a+//+(* ****** ****** *)++fun{a:t0p} gabs_val (x: a):<> a+fun{a:t0p} gneg_val (x: a):<> a+fun{a:t0p} gsucc_val (x: a):<> a+fun{a:t0p} gpred_val (x: a):<> a+fun{a:t0p} grecip_val (x: a):<!exn> a++(* ****** ****** *)++fun{a:t0p} gadd_val_val (x: a, y: a):<> a+fun{a:t0p} gsub_val_val (x: a, y: a):<> a+fun{a:t0p} gmul_val_val (x: a, y: a):<> a+fun{a:t0p} gdiv_val_val (x: a, y: a):<!exn> a+fun{a:t0p} gmod_val_val (x: a, y: a):<!exn> a++(* ****** ****** *)+//+fun{a:t0p} gadd_val_int (x: a, y: int):<> a+fun{a:t0p} gsub_val_int (x: a, y: int):<> a+//+fun{a:t0p} gmul_int_val (x: int, y: a):<> a+fun{a:t0p} gmul_val_int (x: a, y: int):<> a+//+fun{a:t0p} gdiv_int_val (x: int, y: a):<!exn> a+fun{a:t0p} gdiv_val_int (x: a, y: int):<!exn> a+fun{a:t0p} gmod_val_int (x: a, y: int):<!exn> a+//+(* ****** ****** *)++fun{a:t0p} gsqrt_val (x: a):<!exn> a++(* ****** ****** *)++fun{a:t0p} gconjugate_val (x: a):<> a++(* ****** ****** *)++fun{a:t0p} gpow_int_val (n: intGte(0), x: a):<> a++(* ****** ****** *)++(* end of [gnumber.sats] *)

@@ -0,0 +1,139 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/gorder.atxt+** Time of generation: Thu Jan 11 11:00:06 2018+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: September, 2011 *)+(* ****** ****** *)+typedef SHR(a: type) = a++// for commenting purpose+typedef NSH(a: type) = a++// for commenting purpose+(* ****** ****** *)+//+// HX: generic ordering ops+//+(* ****** ****** *)+//+fun {a:t0p} gisltz_val (x : a) :<> bool++fun {a:t0p} gisltez_val (x : a) :<> bool++//+fun {a:t0p} gisgtz_val (x : a) :<> bool++fun {a:t0p} gisgtez_val (x : a) :<> bool++//+fun {a:t0p} giseqz_val (x : a) :<> bool++fun {a:t0p} gisneqz_val (x : a) :<> bool++//+(* ****** ****** *)+//+fun {a:t0p} glt_val_val (x : a, y : a) :<> bool++fun {a:t0p} glte_val_val (x : a, y : a) :<> bool++//+fun {a:t0p} ggt_val_val (x : a, y : a) :<> bool++fun {a:t0p} ggte_val_val (x : a, y : a) :<> bool++//+(* ****** ****** *)+//+fun {a:t0p} glt_val_int (x : a, y : int) :<> bool++fun {a:t0p} glte_val_int (x : a, y : int) :<> bool++//+fun {a:t0p} ggt_val_int (x : a, y : int) :<> bool++fun {a:t0p} ggte_val_int (x : a, y : int) :<> bool++//+(* ****** ****** *)+//+fun {a:t0p} geq_val_val (x : a, y : a) :<> bool++fun {a:t0p} gneq_val_val (x : a, y : a) :<> bool++//+(* ****** ****** *)+//+fun {a:t0p} geq_val_int (x : a, y : int) :<> bool++fun {a:t0p} gneq_val_int (x : a, y : int) :<> bool++//+(* ****** ****** *)+//+fun {a:t0p} gcompare_val_val (x : a, y : a) :<> int++//+(* ****** ****** *)+//+fun {a:t0p} gmax_val_val (x : a, y : a) :<> (a)++fun {a:t0p} gmin_val_val (x : a, y : a) :<> (a)++//+(* ****** ****** *)+//+fun {a:vt0p} glt_ref_ref (x : &INV(a), y : &a) :<> bool++fun {a:vt0p} glte_ref_ref (x : &INV(a), y : &a) :<> bool++//+fun {a:vt0p} ggt_ref_ref (x : &INV(a), y : &a) :<> bool++fun {a:vt0p} ggte_ref_ref (x : &INV(a), y : &a) :<> bool++//+(* ****** ****** *)+//+fun {a:vt0p} geq_ref_ref (x : &INV(a), y : &a) :<> bool++fun {a:vt0p} gneq_ref_ref (x : &INV(a), y : &a) :<> bool++//+(* ****** ****** *)+//+fun {a:vt0p} gcompare_ref_ref (x : &INV(a), y : &a) :<> int++//+(* ****** ****** *)+(* end of [gorder.sats] *)

@@ -0,0 +1,172 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)++(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)++(* ****** ****** *)++(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/gorder.atxt+** Time of generation: Thu Jan 11 11:00:06 2018+*)++(* ****** ****** *)++(* Author: Hongwei Xi *)+(* Authoremail: hwxi AT cs DOT bu DOT edu *)+(* Start time: September, 2011 *)++(* ****** ****** *)++typedef SHR(a:type) = a // for commenting purpose+typedef NSH(a:type) = a // for commenting purpose++(* ****** ****** *)+//+// HX: generic ordering ops+//+(* ****** ****** *)+//+fun+{a:t0p}+gisltz_val (x: a):<> bool+fun+{a:t0p}+gisltez_val (x: a):<> bool+//+fun+{a:t0p}+gisgtz_val (x: a):<> bool+fun+{a:t0p}+gisgtez_val (x: a):<> bool+//+fun+{a:t0p}+giseqz_val (x: a):<> bool+fun+{a:t0p}+gisneqz_val (x: a):<> bool+//+(* ****** ****** *)+//+fun+{a:t0p}+glt_val_val (x: a, y: a):<> bool+fun+{a:t0p}+glte_val_val (x: a, y: a):<> bool+//+fun+{a:t0p}+ggt_val_val (x: a, y: a):<> bool+fun+{a:t0p}+ggte_val_val (x: a, y: a):<> bool+//+(* ****** ****** *)+//+fun+{a:t0p}+glt_val_int (x: a, y: int):<> bool+fun+{a:t0p}+glte_val_int (x: a, y: int):<> bool+//+fun+{a:t0p}+ggt_val_int (x: a, y: int):<> bool+fun+{a:t0p}+ggte_val_int (x: a, y: int):<> bool+//+(* ****** ****** *)+//+fun+{a:t0p}+geq_val_val (x: a, y: a):<> bool+fun+{a:t0p}+gneq_val_val (x: a, y: a):<> bool+//+(* ****** ****** *)+//+fun+{a:t0p}+geq_val_int (x: a, y: int):<> bool+fun+{a:t0p}+gneq_val_int (x: a, y: int):<> bool+//+(* ****** ****** *)+//+fun+{a:t0p}+gcompare_val_val (x: a, y: a):<> int+//+(* ****** ****** *)+//+fun+{a:t0p}+gmax_val_val (x: a, y: a):<> (a)+fun+{a:t0p}+gmin_val_val (x: a, y: a):<> (a)+//+(* ****** ****** *)+//+fun+{a:vt0p}+glt_ref_ref (x: &INV(a), y: &a):<> bool+fun+{a:vt0p}+glte_ref_ref (x: &INV(a), y: &a):<> bool+//+fun+{a:vt0p}+ggt_ref_ref (x: &INV(a), y: &a):<> bool+fun+{a:vt0p}+ggte_ref_ref (x: &INV(a), y: &a):<> bool+//+(* ****** ****** *)+//+fun+{a:vt0p}+geq_ref_ref (x: &INV(a), y: &a):<> bool+fun+{a:vt0p}+gneq_ref_ref (x: &INV(a), y: &a):<> bool+//+(* ****** ****** *)+//+fun+{a:vt0p}+gcompare_ref_ref (x: &INV(a), y: &a):<> int+//+(* ****** ****** *)++(* end of [gorder.sats] *)

@@ -0,0 +1,1436 @@+(***********************************************************************)+(*                                                                     *)+(*                         Applied Type System                         *)+(*                                                                     *)+(***********************************************************************)+(*+** ATS/Postiats - Unleashing the Potential of Types!+** Copyright (C) 2010-2015 Hongwei Xi, ATS Trustful Software, Inc.+** All rights reserved+**+** ATS is free software;  you can  redistribute it and/or modify it under+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the+** Free Software Foundation; either version 3, or (at  your  option)  any+** later version.+**+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License+** for more details.+**+** You  should  have  received  a  copy of the GNU General Public License+** along  with  ATS;  see the  file COPYING.  If not, please write to the+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA+** 02110-1301, USA.+*)+(* ****** ****** *)+(* Author: Hongwei Xi *)+(* Authoremail: gmhwxiATgmailDOTcom *)+(* Start time: January, 2013 *)+(* ****** ****** *)+(*+** Source:+** $PATSHOME/prelude/SATS/CODEGEN/integer_fixed.atxt+** Time of generation: Thu Jan 11 11:00:05 2018+*)+(* ****** ****** *)+//+// HX: for unindexed integer types+//+(* ****** ****** *)+sortdef tk = tkind++(* ****** ****** *)+//+stadef int8knd  = int8_kind+stadef int16knd  = int16_kind+stadef int32knd  = int32_kind+stadef int64knd  = int64_kind++//+stadef uint8knd  = uint8_kind+stadef uint16knd  = uint16_kind+stadef uint32knd  = uint32_kind+stadef uint64knd  = uint64_kind++//+(* ****** ****** *)+//+fun g0int2int_int8_int(x : int8) :<> int =+  "mac#%"++fun g0int2int_int16_int(x : int16) :<> int =+  "mac#%"++fun g0int2int_int32_int(x : int32) :<> int =+  "mac#%"++fun g0int2int_int64_int(x : int64) :<> int =+  "mac#%"++//+(* ****** ****** *)+//+fun g0int_neg_int8(x : int8) :<> int8 =+  "mac#%"++fun g0int_abs_int8(x : int8) :<> int8 =+  "mac#%"++fun g0int_succ_int8(x : int8) :<> int8 =+  "mac#%"++fun g0int_pred_int8(x : int8) :<> int8 =+  "mac#%"++fun g0int_half_int8(x : int8) :<> int8 =+  "mac#%"++fun g0int_asl_int8(x : int8, n : intGte(0)) :<> int8 =+  "mac#%"++fun g0int_asr_int8(x : int8, n : intGte(0)) :<> int8 =+  "mac#%"++fun g0int_add_int8(x : int8, y : int8) :<> int8 =+  "mac#%"++fun g0int_sub_int8(x : int8, y : int8) :<> int8 =+  "mac#%"++fun g0int_mul_int8(x : int8, y : int8) :<> int8 =+  "mac#%"++fun g0int_div_int8(x : int8, y : int8) :<> int8 =+  "mac#%"++fun g0int_mod_int8(x : int8, y : int8) :<> int8 =+  "mac#%"++fun g0int_lt_int8(x : int8, y : int8) :<> bool =+  "mac#%"++fun g0int_lte_int8(x : int8, y : int8) :<> bool =+  "mac#%"++fun g0int_gt_int8(x : int8, y : int8) :<> bool =+  "mac#%"++fun g0int_gte_int8(x : int8, y : int8) :<> bool =+  "mac#%"++fun g0int_eq_int8(x : int8, y : int8) :<> bool =+  "mac#%"++fun g0int_neq_int8(x : int8, y : int8) :<> bool =+  "mac#%"++fun g0int_compare_int8(x : int8, y : int8) :<> int =+  "mac#%"++fun g0int_max_int8(x : int8, y : int8) :<> int8 =+  "mac#%"++fun g0int_min_int8(x : int8, y : int8) :<> int8 =+  "mac#%"++fun g0int_isltz_int8(x : int8) :<> bool =+  "mac#%"++fun g0int_isltez_int8(x : int8) :<> bool =+  "mac#%"++fun g0int_isgtz_int8(x : int8) :<> bool =+  "mac#%"++fun g0int_isgtez_int8(x : int8) :<> bool =+  "mac#%"++fun g0int_iseqz_int8(x : int8) :<> bool =+  "mac#%"++fun g0int_isneqz_int8(x : int8) :<> bool =+  "mac#%"++//+fun g0int_neg_int16(x : int16) :<> int16 =+  "mac#%"++fun g0int_abs_int16(x : int16) :<> int16 =+  "mac#%"++fun g0int_succ_int16(x : int16) :<> int16 =+  "mac#%"++fun g0int_pred_int16(x : int16) :<> int16 =+  "mac#%"++fun g0int_half_int16(x : int16) :<> int16 =+  "mac#%"++fun g0int_asl_int16(x : int16, n : intGte(0)) :<> int16 =+  "mac#%"++fun g0int_asr_int16(x : int16, n : intGte(0)) :<> int16 =+  "mac#%"++fun g0int_add_int16(x : int16, y : int16) :<> int16 =+  "mac#%"++fun g0int_sub_int16(x : int16, y : int16) :<> int16 =+  "mac#%"++fun g0int_mul_int16(x : int16, y : int16) :<> int16 =+  "mac#%"++fun g0int_div_int16(x : int16, y : int16) :<> int16 =+  "mac#%"++fun g0int_mod_int16(x : int16, y : int16) :<> int16 =+  "mac#%"++fun g0int_lt_int16(x : int16, y : int16) :<> bool =+  "mac#%"++fun g0int_lte_int16(x : int16, y : int16) :<> bool =+  "mac#%"++fun g0int_gt_int16(x : int16, y : int16) :<> bool =+  "mac#%"++fun g0int_gte_int16(x : int16, y : int16) :<> bool =+  "mac#%"++fun g0int_eq_int16(x : int16, y : int16) :<> bool =+  "mac#%"++fun g0int_neq_int16(x : int16, y : int16) :<> bool =+  "mac#%"++fun g0int_compare_int16(x : int16, y : int16) :<> int =+  "mac#%"++fun g0int_max_int16(x : int16, y : int16) :<> int16 =+  "mac#%"++fun g0int_min_int16(x : int16, y : int16) :<> int16 =+  "mac#%"++fun g0int_isltz_int16(x : int16) :<> bool =+  "mac#%"++fun g0int_isltez_int16(x : int16) :<> bool =+  "mac#%"++fun g0int_isgtz_int16(x : int16) :<> bool =+  "mac#%"++fun g0int_isgtez_int16(x : int16) :<> bool =+  "mac#%"++fun g0int_iseqz_int16(x : int16) :<> bool =+  "mac#%"++fun g0int_isneqz_int16(x : int16) :<> bool =+  "mac#%"++//+fun g0int_neg_int32(x : int32) :<> int32 =+  "mac#%"++fun g0int_abs_int32(x : int32) :<> int32 =+  "mac#%"++fun g0int_succ_int32(x : int32) :<> int32 =+  "mac#%"++fun g0int_pred_int32(x : int32) :<> int32 =+  "mac#%"++fun g0int_half_int32(x : int32) :<> int32 =+  "mac#%"++fun g0int_asl_int32(x : int32, n : intGte(0)) :<> int32 =+  "mac#%"++fun g0int_asr_int32(x : int32, n : intGte(0)) :<> int32 =+  "mac#%"++fun g0int_add_int32(x : int32, y : int32) :<> int32 =+  "mac#%"++fun g0int_sub_int32(x : int32, y : int32) :<> int32 =+  "mac#%"++fun g0int_mul_int32(x : int32, y : int32) :<> int32 =+  "mac#%"++fun g0int_div_int32(x : int32, y : int32) :<> int32 =+  "mac#%"++fun g0int_mod_int32(x : int32, y : int32) :<> int32 =+  "mac#%"++fun g0int_lt_int32(x : int32, y : int32) :<> bool =+  "mac#%"++fun g0int_lte_int32(x : int32, y : int32) :<> bool =+  "mac#%"++fun g0int_gt_int32(x : int32, y : int32) :<> bool =+  "mac#%"++fun g0int_gte_int32(x : int32, y : int32) :<> bool =+  "mac#%"++fun g0int_eq_int32(x : int32, y : int32) :<> bool =+  "mac#%"++fun g0int_neq_int32(x : int32, y : int32) :<> bool =+  "mac#%"++fun g0int_compare_int32(x : int32, y : int32) :<> int =+  "mac#%"++fun g0int_max_int32(x : int32, y : int32) :<> int32 =+  "mac#%"++fun g0int_min_int32(x : int32, y : int32) :<> int32 =+  "mac#%"++fun g0int_isltz_int32(x : int32) :<> bool =+  "mac#%"++fun g0int_isltez_int32(x : int32) :<> bool =+  "mac#%"++fun g0int_isgtz_int32(x : int32) :<> bool =+  "mac#%"++fun g0int_isgtez_int32(x : int32) :<> bool =+  "mac#%"++fun g0int_iseqz_int32(x : int32) :<> bool =+  "mac#%"++fun g0int_isneqz_int32(x : int32) :<> bool =+  "mac#%"++//+fun g0int_neg_int64(x : int64) :<> int64 =+  "mac#%"++fun g0int_abs_int64(x : int64) :<> int64 =+  "mac#%"++fun g0int_succ_int64(x : int64) :<> int64 =+  "mac#%"++fun g0int_pred_int64(x : int64) :<> int64 =+  "mac#%"++fun g0int_half_int64(x : int64) :<> int64 =+  "mac#%"++fun g0int_asl_int64(x : int64, n : intGte(0)) :<> int64 =+  "mac#%"++fun g0int_asr_int64(x : int64, n : intGte(0)) :<> int64 =+  "mac#%"++fun g0int_add_int64(x : int64, y : int64) :<> int64 =+  "mac#%"++fun g0int_sub_int64(x : int64, y : int64) :<> int64 =+  "mac#%"++fun g0int_mul_int64(x : int64, y : int64) :<> int64 =+  "mac#%"++fun g0int_div_int64(x : int64, y : int64) :<> int64 =+  "mac#%"++fun g0int_mod_int64(x : int64, y : int64) :<> int64 =+  "mac#%"++fun g0int_lt_int64(x : int64, y : int64) :<> bool =+  "mac#%"++fun g0int_lte_int64(x : int64, y : int64) :<> bool =+  "mac#%"++fun g0int_gt_int64(x : int64, y : int64) :<> bool =+  "mac#%"++fun g0int_gte_int64(x : int64, y : int64) :<> bool =+  "mac#%"++fun g0int_eq_int64(x : int64, y : int64) :<> bool =+  "mac#%"++fun g0int_neq_int64(x : int64, y : int64) :<> bool =+  "mac#%"++fun g0int_compare_int64(x : int64, y : int64) :<> int =+  "mac#%"++fun g0int_max_int64(x : int64, y : int64) :<> int64 =+  "mac#%"++fun g0int_min_int64(x : int64, y : int64) :<> int64 =+  "mac#%"++fun g0int_isltz_int64(x : int64) :<> bool =+  "mac#%"++fun g0int_isltez_int64(x : int64) :<> bool =+  "mac#%"++fun g0int_isgtz_int64(x : int64) :<> bool =+  "mac#%"++fun g0int_isgtez_int64(x : int64) :<> bool =+  "mac#%"++fun g0int_iseqz_int64(x : int64) :<> bool =+  "mac#%"++fun g0int_isneqz_int64(x : int64) :<> bool =+  "mac#%"++//+(* ****** ****** *)+fun print_int8(int8) : void =+  "mac#%"++fun prerr_int8(int8) : void =+  "mac#%"++fun fprint_int8 : fprint_type(int8) =+  "mac#%"++overload print with print_int8++overload prerr with prerr_int8++overload fprint with fprint_int8++fun print_int16(int16) : void =+  "mac#%"++fun prerr_int16(int16) : void =+  "mac#%"++fun fprint_int16 : fprint_type(int16) =+  "mac#%"++overload print with print_int16++overload prerr with prerr_int16++overload fprint with fprint_int16++fun print_int32(int32) : void =+  "mac#%"++fun prerr_int32(int32) : void =+  "mac#%"++fun fprint_int32 : fprint_type(int32) =+  "mac#%"++overload print with print_int32++overload prerr with prerr_int32++overload fprint with fprint_int32++fun print_int64(int64) : void =+  "mac#%"++fun prerr_int64(int64) : void =+  "mac#%"++fun fprint_int64 : fprint_type(int64) =+  "mac#%"++overload print with print_int64++overload prerr with prerr_int64++overload fprint with fprint_int64++(* ****** ****** *)+//+fun g0int2uint_int8_uint(x : int8) :<> uint =+  "mac#%"++fun g0int2uint_int16_uint(x : int16) :<> uint =+  "mac#%"++fun g0int2uint_int32_uint(x : int32) :<> uint =+  "mac#%"++fun g0int2uint_int64_uint(x : int64) :<> uint =+  "mac#%"++//+fun g0uint2int_uint8_int(x : uint8) :<> int =+  "mac#%"++fun g0uint2int_uint16_int(x : uint16) :<> int =+  "mac#%"++fun g0uint2int_uint32_int(x : uint32) :<> int =+  "mac#%"++fun g0uint2int_uint64_int(x : uint64) :<> int =+  "mac#%"++//+fun g0uint2uint_uint8_uint(x : uint8) :<> uint =+  "mac#%"++fun g0uint2uint_uint16_uint(x : uint16) :<> uint =+  "mac#%"++fun g0uint2uint_uint32_uint(x : uint32) :<> uint =+  "mac#%"++fun g0uint2uint_uint64_uint(x : uint64) :<> uint =+  "mac#%"++//+(* ****** ****** *)+//+fun g0uint_succ_uint8(x : uint8) :<> uint8 =+  "mac#%"++fun g0uint_pred_uint8(x : uint8) :<> uint8 =+  "mac#%"++fun g0uint_half_uint8(x : uint8) :<> uint8 =+  "mac#%"++fun g0uint_add_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_sub_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_mul_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_div_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_mod_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_lsl_uint8(x : uint8, n : intGte(0)) :<> uint8 =+  "mac#%"++fun g0uint_lsr_uint8(x : uint8, n : intGte(0)) :<> uint8 =+  "mac#%"++fun g0uint_lnot_uint8(x : uint8) :<> uint8 =+  "mac#%"++fun g0uint_lor_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_lxor_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_land_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_lt_uint8(x : uint8, y : uint8) :<> bool =+  "mac#%"++fun g0uint_lte_uint8(x : uint8, y : uint8) :<> bool =+  "mac#%"++fun g0uint_gt_uint8(x : uint8, y : uint8) :<> bool =+  "mac#%"++fun g0uint_gte_uint8(x : uint8, y : uint8) :<> bool =+  "mac#%"++fun g0uint_eq_uint8(x : uint8, y : uint8) :<> bool =+  "mac#%"++fun g0uint_neq_uint8(x : uint8, y : uint8) :<> bool =+  "mac#%"++fun g0uint_compare_uint8(x : uint8, y : uint8) :<> int =+  "mac#%"++fun g0uint_max_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_min_uint8(x : uint8, y : uint8) :<> uint8 =+  "mac#%"++fun g0uint_isgtz_uint8(x : uint8) :<> bool =+  "mac#%"++fun g0uint_iseqz_uint8(x : uint8) :<> bool =+  "mac#%"++fun g0uint_isneqz_uint8(x : uint8) :<> bool =+  "mac#%"++//+fun g0uint_succ_uint16(x : uint16) :<> uint16 =+  "mac#%"++fun g0uint_pred_uint16(x : uint16) :<> uint16 =+  "mac#%"++fun g0uint_half_uint16(x : uint16) :<> uint16 =+  "mac#%"++fun g0uint_add_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_sub_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_mul_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_div_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_mod_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_lsl_uint16(x : uint16, n : intGte(0)) :<> uint16 =+  "mac#%"++fun g0uint_lsr_uint16(x : uint16, n : intGte(0)) :<> uint16 =+  "mac#%"++fun g0uint_lnot_uint16(x : uint16) :<> uint16 =+  "mac#%"++fun g0uint_lor_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_lxor_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_land_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_lt_uint16(x : uint16, y : uint16) :<> bool =+  "mac#%"++fun g0uint_lte_uint16(x : uint16, y : uint16) :<> bool =+  "mac#%"++fun g0uint_gt_uint16(x : uint16, y : uint16) :<> bool =+  "mac#%"++fun g0uint_gte_uint16(x : uint16, y : uint16) :<> bool =+  "mac#%"++fun g0uint_eq_uint16(x : uint16, y : uint16) :<> bool =+  "mac#%"++fun g0uint_neq_uint16(x : uint16, y : uint16) :<> bool =+  "mac#%"++fun g0uint_compare_uint16(x : uint16, y : uint16) :<> int =+  "mac#%"++fun g0uint_max_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_min_uint16(x : uint16, y : uint16) :<> uint16 =+  "mac#%"++fun g0uint_isgtz_uint16(x : uint16) :<> bool =+  "mac#%"++fun g0uint_iseqz_uint16(x : uint16) :<> bool =+  "mac#%"++fun g0uint_isneqz_uint16(x : uint16) :<> bool =+  "mac#%"++//+fun g0uint_succ_uint32(x : uint32) :<> uint32 =+  "mac#%"++fun g0uint_pred_uint32(x : uint32) :<> uint32 =+  "mac#%"++fun g0uint_half_uint32(x : uint32) :<> uint32 =+  "mac#%"++fun g0uint_add_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_sub_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_mul_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_div_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_mod_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_lsl_uint32(x : uint32, n : intGte(0)) :<> uint32 =+  "mac#%"++fun g0uint_lsr_uint32(x : uint32, n : intGte(0)) :<> uint32 =+  "mac#%"++fun g0uint_lnot_uint32(x : uint32) :<> uint32 =+  "mac#%"++fun g0uint_lor_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_lxor_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_land_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_lt_uint32(x : uint32, y : uint32) :<> bool =+  "mac#%"++fun g0uint_lte_uint32(x : uint32, y : uint32) :<> bool =+  "mac#%"++fun g0uint_gt_uint32(x : uint32, y : uint32) :<> bool =+  "mac#%"++fun g0uint_gte_uint32(x : uint32, y : uint32) :<> bool =+  "mac#%"++fun g0uint_eq_uint32(x : uint32, y : uint32) :<> bool =+  "mac#%"++fun g0uint_neq_uint32(x : uint32, y : uint32) :<> bool =+  "mac#%"++fun g0uint_compare_uint32(x : uint32, y : uint32) :<> int =+  "mac#%"++fun g0uint_max_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_min_uint32(x : uint32, y : uint32) :<> uint32 =+  "mac#%"++fun g0uint_isgtz_uint32(x : uint32) :<> bool =+  "mac#%"++fun g0uint_iseqz_uint32(x : uint32) :<> bool =+  "mac#%"++fun g0uint_isneqz_uint32(x : uint32) :<> bool =+  "mac#%"++//+fun g0uint_succ_uint64(x : uint64) :<> uint64 =+  "mac#%"++fun g0uint_pred_uint64(x : uint64) :<> uint64 =+  "mac#%"++fun g0uint_half_uint64(x : uint64) :<> uint64 =+  "mac#%"++fun g0uint_add_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_sub_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_mul_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_div_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_mod_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_lsl_uint64(x : uint64, n : intGte(0)) :<> uint64 =+  "mac#%"++fun g0uint_lsr_uint64(x : uint64, n : intGte(0)) :<> uint64 =+  "mac#%"++fun g0uint_lnot_uint64(x : uint64) :<> uint64 =+  "mac#%"++fun g0uint_lor_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_lxor_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_land_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_lt_uint64(x : uint64, y : uint64) :<> bool =+  "mac#%"++fun g0uint_lte_uint64(x : uint64, y : uint64) :<> bool =+  "mac#%"++fun g0uint_gt_uint64(x : uint64, y : uint64) :<> bool =+  "mac#%"++fun g0uint_gte_uint64(x : uint64, y : uint64) :<> bool =+  "mac#%"++fun g0uint_eq_uint64(x : uint64, y : uint64) :<> bool =+  "mac#%"++fun g0uint_neq_uint64(x : uint64, y : uint64) :<> bool =+  "mac#%"++fun g0uint_compare_uint64(x : uint64, y : uint64) :<> int =+  "mac#%"++fun g0uint_max_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_min_uint64(x : uint64, y : uint64) :<> uint64 =+  "mac#%"++fun g0uint_isgtz_uint64(x : uint64) :<> bool =+  "mac#%"++fun g0uint_iseqz_uint64(x : uint64) :<> bool =+  "mac#%"++fun g0uint_isneqz_uint64(x : uint64) :<> bool =+  "mac#%"++//+(* ****** ****** *)+fun print_uint8(uint8) : void =+  "mac#%"++fun prerr_uint8(uint8) : void =+  "mac#%"++fun fprint_uint8 : fprint_type(uint8) =+  "mac#%"++overload print with print_uint8++overload prerr with prerr_uint8++overload fprint with fprint_uint8++fun print_uint16(uint16) : void =+  "mac#%"++fun prerr_uint16(uint16) : void =+  "mac#%"++fun fprint_uint16 : fprint_type(uint16) =+  "mac#%"++overload print with print_uint16++overload prerr with prerr_uint16++overload fprint with fprint_uint16++fun print_uint32(uint32) : void =+  "mac#%"++fun prerr_uint32(uint32) : void =+  "mac#%"++fun fprint_uint32 : fprint_type(uint32) =+  "mac#%"++overload print with print_uint32++overload prerr with prerr_uint32++overload fprint with fprint_uint32++fun print_uint64(uint64) : void =+  "mac#%"++fun prerr_uint64(uint64) : void =+  "mac#%"++fun fprint_uint64 : fprint_type(uint64) =+  "mac#%"++overload print with print_uint64++overload prerr with prerr_uint64++overload fprint with fprint_uint64++(* ****** ****** *)+//+fun g1int_neg_int8 : g1int_neg_type(int8knd) =+  "mac#%"++fun g1int_abs_int8 : g1int_abs_type(int8knd) =+  "mac#%"++fun g1int_succ_int8 : g1int_succ_type(int8knd) =+  "mac#%"++fun g1int_pred_int8 : g1int_pred_type(int8knd) =+  "mac#%"++fun g1int_half_int8 : g1int_half_type(int8knd) =+  "mac#%"++fun g1int_add_int8 : g1int_add_type(int8knd) =+  "mac#%"++fun g1int_sub_int8 : g1int_sub_type(int8knd) =+  "mac#%"++fun g1int_mul_int8 : g1int_mul_type(int8knd) =+  "mac#%"++fun g1int_div_int8 : g1int_div_type(int8knd) =+  "mac#%"++fun g1int_nmod_int8 : g1int_nmod_type(int8knd) =+  "mac#%"++fun g1int_lt_int8 : g1int_lt_type(int8knd) =+  "mac#%"++fun g1int_lte_int8 : g1int_lte_type(int8knd) =+  "mac#%"++fun g1int_gt_int8 : g1int_gt_type(int8knd) =+  "mac#%"++fun g1int_gte_int8 : g1int_gte_type(int8knd) =+  "mac#%"++fun g1int_eq_int8 : g1int_eq_type(int8knd) =+  "mac#%"++fun g1int_neq_int8 : g1int_neq_type(int8knd) =+  "mac#%"++fun g1int_compare_int8 : g1int_compare_type(int8knd) =+  "mac#%"++fun g1int_max_int8 : g1int_max_type(int8knd) =+  "mac#%"++fun g1int_min_int8 : g1int_min_type(int8knd) =+  "mac#%"++fun g1int_isltz_int8 : g1int_isltz_type(int8knd) =+  "mac#%"++fun g1int_isltez_int8 : g1int_isltez_type(int8knd) =+  "mac#%"++fun g1int_isgtz_int8 : g1int_isgtz_type(int8knd) =+  "mac#%"++fun g1int_isgtez_int8 : g1int_isgtez_type(int8knd) =+  "mac#%"++fun g1int_iseqz_int8 : g1int_iseqz_type(int8knd) =+  "mac#%"++fun g1int_isneqz_int8 : g1int_isneqz_type(int8knd) =+  "mac#%"++//+fun g1int_neg_int16 : g1int_neg_type(int16knd) =+  "mac#%"++fun g1int_abs_int16 : g1int_abs_type(int16knd) =+  "mac#%"++fun g1int_succ_int16 : g1int_succ_type(int16knd) =+  "mac#%"++fun g1int_pred_int16 : g1int_pred_type(int16knd) =+  "mac#%"++fun g1int_half_int16 : g1int_half_type(int16knd) =+  "mac#%"++fun g1int_add_int16 : g1int_add_type(int16knd) =+  "mac#%"++fun g1int_sub_int16 : g1int_sub_type(int16knd) =+  "mac#%"++fun g1int_mul_int16 : g1int_mul_type(int16knd) =+  "mac#%"++fun g1int_div_int16 : g1int_div_type(int16knd) =+  "mac#%"++fun g1int_nmod_int16 : g1int_nmod_type(int16knd) =+  "mac#%"++fun g1int_lt_int16 : g1int_lt_type(int16knd) =+  "mac#%"++fun g1int_lte_int16 : g1int_lte_type(int16knd) =+  "mac#%"++fun g1int_gt_int16 : g1int_gt_type(int16knd) =+  "mac#%"++fun g1int_gte_int16 : g1int_gte_type(int16knd) =+  "mac#%"++fun g1int_eq_int16 : g1int_eq_type(int16knd) =+  "mac#%"++fun g1int_neq_int16 : g1int_neq_type(int16knd) =+  "mac#%"++fun g1int_compare_int16 : g1int_compare_type(int16knd) =+  "mac#%"++fun g1int_max_int16 : g1int_max_type(int16knd) =+  "mac#%"++fun g1int_min_int16 : g1int_min_type(int16knd) =+  "mac#%"++fun g1int_isltz_int16 : g1int_isltz_type(int16knd) =+  "mac#%"++fun g1int_isltez_int16 : g1int_isltez_type(int16knd) =+  "mac#%"++fun g1int_isgtz_int16 : g1int_isgtz_type(int16knd) =+  "mac#%"++fun g1int_isgtez_int16 : g1int_isgtez_type(int16knd) =+  "mac#%"++fun g1int_iseqz_int16 : g1int_iseqz_type(int16knd) =+  "mac#%"++fun g1int_isneqz_int16 : g1int_isneqz_type(int16knd) =+  "mac#%"++//+fun g1int_neg_int32 : g1int_neg_type(int32knd) =+  "mac#%"++fun g1int_abs_int32 : g1int_abs_type(int32knd) =+  "mac#%"++fun g1int_succ_int32 : g1int_succ_type(int32knd) =+  "mac#%"++fun g1int_pred_int32 : g1int_pred_type(int32knd) =+  "mac#%"++fun g1int_half_int32 : g1int_half_type(int32knd) =+  "mac#%"++fun g1int_add_int32 : g1int_add_type(int32knd) =+  "mac#%"++fun g1int_sub_int32 : g1int_sub_type(int32knd) =+  "mac#%"++fun g1int_mul_int32 : g1int_mul_type(int32knd) =+  "mac#%"++fun g1int_div_int32 : g1int_div_type(int32knd) =+  "mac#%"++fun g1int_nmod_int32 : g1int_nmod_type(int32knd) =+  "mac#%"++fun g1int_lt_int32 : g1int_lt_type(int32knd) =+  "mac#%"++fun g1int_lte_int32 : g1int_lte_type(int32knd) =+  "mac#%"++fun g1int_gt_int32 : g1int_gt_type(int32knd) =+  "mac#%"++fun g1int_gte_int32 : g1int_gte_type(int32knd) =+  "mac#%"++fun g1int_eq_int32 : g1int_eq_type(int32knd) =+  "mac#%"++fun g1int_neq_int32 : g1int_neq_type(int32knd) =+  "mac#%"++fun g1int_compare_int32 : g1int_compare_type(int32knd) =+  "mac#%"++fun g1int_max_int32 : g1int_max_type(int32knd) =+  "mac#%"++fun g1int_min_int32 : g1int_min_type(int32knd) =+  "mac#%"++fun g1int_isltz_int32 : g1int_isltz_type(int32knd) =+  "mac#%"++fun g1int_isltez_int32 : g1int_isltez_type(int32knd) =+  "mac#%"++fun g1int_isgtz_int32 : g1int_isgtz_type(int32knd) =+  "mac#%"++fun g1int_isgtez_int32 : g1int_isgtez_type(int32knd) =+  "mac#%"++fun g1int_iseqz_int32 : g1int_iseqz_type(int32knd) =+  "mac#%"++fun g1int_isneqz_int32 : g1int_isneqz_type(int32knd) =+  "mac#%"++//+fun g1int_neg_int64 : g1int_neg_type(int64knd) =+  "mac#%"++fun g1int_abs_int64 : g1int_abs_type(int64knd) =+  "mac#%"++fun g1int_succ_int64 : g1int_succ_type(int64knd) =+  "mac#%"++fun g1int_pred_int64 : g1int_pred_type(int64knd) =+  "mac#%"++fun g1int_half_int64 : g1int_half_type(int64knd) =+  "mac#%"++fun g1int_add_int64 : g1int_add_type(int64knd) =+  "mac#%"++fun g1int_sub_int64 : g1int_sub_type(int64knd) =+  "mac#%"++fun g1int_mul_int64 : g1int_mul_type(int64knd) =+  "mac#%"++fun g1int_div_int64 : g1int_div_type(int64knd) =+  "mac#%"++fun g1int_nmod_int64 : g1int_nmod_type(int64knd) =+  "mac#%"++fun g1int_lt_int64 : g1int_lt_type(int64knd) =+  "mac#%"++fun g1int_lte_int64 : g1int_lte_type(int64knd) =+  "mac#%"++fun g1int_gt_int64 : g1int_gt_type(int64knd) =+  "mac#%"++fun g1int_gte_int64 : g1int_gte_type(int64knd) =+  "mac#%"++fun g1int_eq_int64 : g1int_eq_type(int64knd) =+  "mac#%"++fun g1int_neq_int64 : g1int_neq_type(int64knd) =+  "mac#%"++fun g1int_compare_int64 : g1int_compare_type(int64knd) =+  "mac#%"++fun g1int_max_int64 : g1int_max_type(int64knd) =+  "mac#%"++fun g1int_min_int64 : g1int_min_type(int64knd) =+  "mac#%"++fun g1int_isltz_int64 : g1int_isltz_type(int64knd) =+  "mac#%"++fun g1int_isltez_int64 : g1int_isltez_type(int64knd) =+  "mac#%"++fun g1int_isgtz_int64 : g1int_isgtz_type(int64knd) =+  "mac#%"++fun g1int_isgtez_int64 : g1int_isgtez_type(int64knd) =+  "mac#%"++fun g1int_iseqz_int64 : g1int_iseqz_type(int64knd) =+  "mac#%"++fun g1int_isneqz_int64 : g1int_isneqz_type(int64knd) =+  "mac#%"++//+(* ****** ****** *)+//+fun g1uint_succ_uint8 : g1uint_succ_type(uint8knd) =+  "mac#%"++fun g1uint_pred_uint8 : g1uint_pred_type(uint8knd) =+  "mac#%"++fun g1uint_half_uint8 : g1uint_half_type(uint8knd) =+  "mac#%"++fun g1uint_add_uint8 : g1uint_add_type(uint8knd) =+  "mac#%"++fun g1uint_sub_uint8 : g1uint_sub_type(uint8knd) =+  "mac#%"++fun g1uint_mul_uint8 : g1uint_mul_type(uint8knd) =+  "mac#%"++fun g1uint_div_uint8 : g1uint_div_type(uint8knd) =+  "mac#%"++fun g1uint_mod_uint8 : g1uint_mod_type(uint8knd) =+  "mac#%"++fun g1uint_lt_uint8 : g1uint_lt_type(uint8knd) =+  "mac#%"++fun g1uint_lte_uint8 : g1uint_lte_type(uint8knd) =+  "mac#%"++fun g1uint_gt_uint8 : g1uint_gt_type(uint8knd) =+  "mac#%"++fun g1uint_gte_uint8 : g1uint_gte_type(uint8knd) =+  "mac#%"++fun g1uint_eq_uint8 : g1uint_eq_type(uint8knd) =+  "mac#%"++fun g1uint_neq_uint8 : g1uint_neq_type(uint8knd) =+  "mac#%"++fun g1uint_compare_uint8 : g1uint_compare_type(uint8knd) =+  "mac#%"++fun g1uint_max_uint8 : g1uint_max_type(uint8knd) =+  "mac#%"++fun g1uint_min_uint8 : g1uint_min_type(uint8knd) =+  "mac#%"++fun g1uint_isgtz_uint8 : g1uint_isgtz_type(uint8knd) =+  "mac#%"++fun g1uint_iseqz_uint8 : g1uint_iseqz_type(uint8knd) =+  "mac#%"++fun g1uint_isneqz_uint8 : g1uint_isneqz_type(uint8knd) =+  "mac#%"++//+fun g1uint_succ_uint16 : g1uint_succ_type(uint16knd) =+  "mac#%"++fun g1uint_pred_uint16 : g1uint_pred_type(uint16knd) =+  "mac#%"++fun g1uint_half_uint16 : g1uint_half_type(uint16knd) =+  "mac#%"++fun g1uint_add_uint16 : g1uint_add_type(uint16knd) =+  "mac#%"++fun g1uint_sub_uint16 : g1uint_sub_type(uint16knd) =+  "mac#%"++fun g1uint_mul_uint16 : g1uint_mul_type(uint16knd) =+  "mac#%"++fun g1uint_div_uint16 : g1uint_div_type(uint16knd) =+  "mac#%"++fun g1uint_mod_uint16 : g1uint_mod_type(uint16knd) =+  "mac#%"++fun g1uint_lt_uint16 : g1uint_lt_type(uint16knd) =+  "mac#%"++fun g1uint_lte_uint16 : g1uint_lte_type(uint16knd) =+  "mac#%"++fun g1uint_gt_uint16 : g1uint_gt_type(uint16knd) =+  "mac#%"++fun g1uint_gte_uint16 : g1uint_gte_type(uint16knd) =+  "mac#%"++fun g1uint_eq_uint16 : g1uint_eq_type(uint16knd) =+  "mac#%"++fun g1uint_neq_uint16 : g1uint_neq_type(uint16knd) =+  "mac#%"++fun g1uint_compare_uint16 : g1uint_compare_type(uint16knd) =+  "mac#%"++fun g1uint_max_uint16 : g1uint_max_type(uint16knd) =+  "mac#%"++fun g1uint_min_uint16 : g1uint_min_type(uint16knd) =+  "mac#%"++fun g1uint_isgtz_uint16 : g1uint_isgtz_type(uint16knd) =+  "mac#%"++fun g1uint_iseqz_uint16 : g1uint_iseqz_type(uint16knd) =+  "mac#%"++fun g1uint_isneqz_uint16 : g1uint_isneqz_type(uint16knd) =+  "mac#%"++//+fun g1uint_succ_uint32 : g1uint_succ_type(uint32knd) =+  "mac#%"++fun g1uint_pred_uint32 : g1uint_pred_type(uint32knd) =+  "mac#%"++fun g1uint_half_uint32 : g1uint_half_type(uint32knd) =+  "mac#%"++fun g1uint_add_uint32 : g1uint_add_type(uint32knd) =+  "mac#%"++fun g1uint_sub_uint32 : g1uint_sub_type(uint32knd) =+  "mac#%"++fun g1uint_mul_uint32 : g1uint_mul_type(uint32knd) =+  "mac#%"++fun g1uint_div_uint32 : g1uint_div_type(uint32knd) =+  "mac#%"++fun g1uint_mod_uint32 : g1uint_mod_type(uint32knd) =+  "mac#%"++fun g1uint_lt_uint32 : g1uint_lt_type(uint32knd) =+  "mac#%"++fun g1uint_lte_uint32 : g1uint_lte_type(uint32knd) =+  "mac#%"++fun g1uint_gt_uint32 : g1uint_gt_type(uint32knd) =+  "mac#%"++fun g1uint_gte_uint32 : g1uint_gte_type(uint32knd) =+  "mac#%"++fun g1uint_eq_uint32 : g1uint_eq_type(uint32knd) =+  "mac#%"++fun g1uint_neq_uint32 : g1uint_neq_type(uint32knd) =+  "mac#%"++fun g1uint_compare_uint32 : g1uint_compare_type(uint32knd) =+  "mac#%"++fun g1uint_max_uint32 : g1uint_max_type(uint32knd) =+  "mac#%"++fun g1uint_min_uint32 : g1uint_min_type(uint32knd) =+  "mac#%"++fun g1uint_isgtz_uint32 : g1uint_isgtz_type(uint32knd) =+  "mac#%"++fun g1uint_iseqz_uint32 : g1uint_iseqz_type(uint32knd) =+  "mac#%"++fun g1uint_isneqz_uint32 : g1uint_isneqz_type(uint32knd) =+  "mac#%"++//+fun g1uint_succ_uint64 : g1uint_succ_type(uint64knd) =+  "mac#%"++fun g1uint_pred_uint64 : g1uint_pred_type(uint64knd) =+  "mac#%"++fun g1uint_half_uint64 : g1uint_half_type(uint64knd) =+  "mac#%"++fun g1uint_add_uint64 : g1uint_add_type(uint64knd) =+  "mac#%"++fun g1uint_sub_uint64 : g1uint_sub_type(uint64knd) =+  "mac#%"++fun g1uint_mul_uint64 : g1uint_mul_type(uint64knd) =+  "mac#%"++fun g1uint_div_uint64 : g1uint_div_type(uint64knd) =+  "mac#%"++fun g1uint_mod_uint64 : g1uint_mod_type(uint64knd) =+  "mac#%"++fun g1uint_lt_uint64 : g1uint_lt_type(uint64knd) =+  "mac#%"++fun g1uint_lte_uint64 : g1uint_lte_type(uint64knd) =+  "mac#%"++fun g1uint_gt_uint64 : g1uint_gt_type(uint64knd) =+  "mac#%"++fun g1uint_gte_uint64 : g1uint_gte_type(uint64knd) =+  "mac#%"++fun g1uint_eq_uint64 : g1uint_eq_type(uint64knd) =+  "mac#%"++fun g1uint_neq_uint64 : g1uint_neq_type(uint64knd) =+  "mac#%"++fun g1uint_compare_uint64 : g1uint_compare_type(uint64knd) =+  "mac#%"++fun g1uint_max_uint64 : g1uint_max_type(uint64knd) =+  "mac#%"++fun g1uint_min_uint64 : g1uint_min_type(uint64knd) =+  "mac#%"++fun g1uint_isgtz_uint64 : g1uint_isgtz_type(uint64knd) =+  "mac#%"++fun g1uint_iseqz_uint64 : g1uint_iseqz_type(uint64knd) =+  "mac#%"++fun g1uint_isneqz_uint64 : g1uint_isneqz_type(uint64knd) =+  "mac#%"++//+(* ****** ****** *)+(* end of [integer_fixed.sats] *)