acw/cryptonum
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix a bunch of build errors.

Browse Source
This commit is contained in:
Adam Wick
2019-10-24 08:46:42 -07:00
parent 620048bce6
commit 0dec5815dc
5 changed files with 80 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
generation/src/Base.hs
View File

@@ -33,7 +33,7 @@ declareBaseStructure bitsize =
#[derive(Clone)] #[derive(Clone)]
pub struct $$sname { pub struct $$sname {
value: [u64; $$(entriese)] pub(crate) value: [u64; $$(entriese)]
} }
impl fmt::Debug for $$sname { impl fmt::Debug for $$sname {
@@ -59,7 +59,7 @@ declareBaseStructure bitsize =
impl Arbitrary for $$sname { impl Arbitrary for $$sname {
fn arbitrary<G: Gen>(g: &mut G) -> Self { fn arbitrary<G: Gen>(g: &mut G) -> Self {
let mut res = $$sname{ value: [0; $$(entriese)] }; let mut res = $$sname{ value: [0; $$(entriese)] };
for entry in res.iter_mut() { for entry in res.value.iter_mut() {
*entry = g.next_u64(); *entry = g.next_u64();
} }
res res

64
generation/src/BinaryOps.hs
View File

@@ -5,6 +5,7 @@ module BinaryOps(
where where
import File import File
import Gen(toLit)
import Language.Rust.Data.Ident import Language.Rust.Data.Ident
import Language.Rust.Data.Position import Language.Rust.Data.Position
import Language.Rust.Quote import Language.Rust.Quote
@@ -51,15 +52,16 @@ declareBinaryOperators bitsize =
} }
impl<'a> Not for &'a $$struct_name { impl<'a> Not for &'a $$struct_name {
type Output = Self; type Output = $$struct_name;
fn not(self) -> Self { fn not(self) -> Self::Output {
let mut output = self.clone(); let mut output = self.clone();
$@{refNegationStmts} $@{refNegationStmts}
output output
} }
} }
#[cfg(test)]
quickcheck! { quickcheck! {
fn and_associative(a: $$struct_name, b: $$struct_name, c: $$struct_name) -> bool { fn and_associative(a: $$struct_name, b: $$struct_name, c: $$struct_name) -> bool {
((&a & &b) & &c) == (&a & (&b & &c)) ((&a & &b) & &c) == (&a & (&b & &c))
@@ -92,10 +94,10 @@ declareBinaryOperators bitsize =
(&a & (&b | &c)) == ((&a & &b) | (&a & &c)) (&a & (&b | &c)) == ((&a & &b) | (&a & &c))
} }
fn xor_clears(a: $$struct_name) -> bool { fn xor_clears(a: $$struct_name) -> bool {
$$struct_name::zero() == (&a ^ *a) $$struct_name::zero() == (&a ^ &a)
} }
fn double_neg_ident(a: $$struct_name) -> bool { fn double_neg_ident(a: $$struct_name) -> bool {
a == !!$a a == !!&a
} }
fn and_ident(a: $$struct_name) -> bool { fn and_ident(a: $$struct_name) -> bool {
let ones = !$$struct_name::zero(); let ones = !$$struct_name::zero();
@@ -111,13 +113,14 @@ negationStatements :: String -> Word -> [Stmt Span]
negationStatements target entries = map genStatement [0..entries-1] negationStatements target entries = map genStatement [0..entries-1]
where where
genStatement i = genStatement i =
let idx = Lit [] (Int Dec (fromIntegral i) Unsuffixed mempty) mempty let idx = toLit i
v = mkIdent target v = mkIdent target
in [stmt| $$v.value[$$(idx)] = !self.value[$$(idx)]; |] in [stmt| $$v.value[$$(idx)] = !self.value[$$(idx)]; |]
generateBinOps :: String -> Ident -> String -> BinOp -> Word -> [Item Span] generateBinOps :: String -> Ident -> String -> BinOp -> Word -> [Item Span]
generateBinOps trait sname func oper entries = generateBinOps trait sname func oper entries =
[normAssign, refAssign] ++ generateAllTheVariants traitIdent funcIdent sname oper [normAssign, refAssign] ++
generateAllTheVariants traitIdent funcIdent sname oper entries
where where
traitIdent = mkIdent trait traitIdent = mkIdent trait
assignIdent = mkIdent (trait ++ "Assign") assignIdent = mkIdent (trait ++ "Assign")
@@ -132,7 +135,7 @@ generateBinOps trait sname func oper entries =
} }
|] |]
refAssign = [item| refAssign = [item|
impl $$assignIdent<&'a $$sname> for $$sname { impl<'a> $$assignIdent<&'a $$sname> for $$sname {
fn $$funcAssignIdent(&mut self, rhs: &Self) { fn $$funcAssignIdent(&mut self, rhs: &Self) {
$@{assignStatements} $@{assignStatements}
} }
@@ -142,54 +145,57 @@ generateBinOps trait sname func oper entries =
assignStatements :: [Stmt Span] assignStatements :: [Stmt Span]
assignStatements = map genAssign [0..entries-1] assignStatements = map genAssign [0..entries-1]
genAssign i = genAssign i =
let idx = Lit [] (Int Dec (fromIntegral i) Unsuffixed mempty) mempty let idx = toLit i
left = [expr| self.value[$$(idx)] |] left = [expr| self.value[$$(idx)] |]
right = [expr| rhs.value[$$(idx)] |] right = [expr| rhs.value[$$(idx)] |]
in Semi (AssignOp [] oper left right mempty) mempty in Semi (AssignOp [] oper left right mempty) mempty
generateAllTheVariants :: Ident -> Ident -> Ident -> BinOp -> [Item Span] generateAllTheVariants :: Ident -> Ident -> Ident -> BinOp -> Word -> [Item Span]
generateAllTheVariants traitname func sname oper = [ generateAllTheVariants traitname func sname oper entries = [
[item| [item|
impl $$traitname for $$sname { impl $$traitname for $$sname {
type Output = Self; type Output = $$sname;
fn $$func(mut self, rhs: Self) -> Self { fn $$func(mut self, rhs: $$sname) -> Self::Output {
$${assigner_self_rhs} $@{assigners_self_rhs}
self self
} }
}|] }|]
, [item| , [item|
impl<'a> $$traitname<&'a $$sname> for $$sname { impl<'a> $$traitname<&'a $$sname> for $$sname {
type Output = Self; type Output = $$sname;
fn $$func(mut self, rhs: Self) -> Self { fn $$func(mut self, rhs: &$$sname) -> Self::Output {
$${assigner_self_rhs} $@{assigners_self_rhs}
self self
} }
}|] }|]
, [item| , [item|
impl<'a> $$traitname for &'a $$sname { impl<'a> $$traitname<$$sname> for &'a $$sname {
type Output = Self; type Output = $$sname;
fn $$func(mut self, rhs: Self) -> Self { fn $$func(self, mut rhs: $$sname) -> Self::Output {
$${assigner_rhs_self} $@{assigners_rhs_self}
self rhs
} }
}|] }|]
, [item| , [item|
impl<'a,'b> $$traitname<&'a $$sname> for &'b $$sname { impl<'a,'b> $$traitname<&'a $$sname> for &'b $$sname {
type Output = Self; type Output = $$sname;
fn $$func(mut self, rhs: Self) -> Self { fn $$func(self, rhs: &$$sname) -> Self::Output {
let mut out = self.clone(); let mut out = self.clone();
$${assigner_out_rhs} $@{assigners_out_rhs}
out out
} }
}|] }|]
] ]
where where
assigner_self_rhs = assigner [expr| self |] [expr| rhs |] assigners_self_rhs = assigners [expr| self |] [expr| rhs |]
assigner_rhs_self = assigner [expr| rhs |] [expr| self |] assigners_rhs_self = assigners [expr| rhs |] [expr| self |]
assigner_out_rhs = assigner [expr| out |] [expr| rhs |] assigners_out_rhs = assigners [expr| out |] [expr| rhs |]
assigner left right = assigners left right = map (genAssign left right . toLit) [0..entries-1]
Semi (AssignOp [] oper left right mempty) mempty genAssign left right i =
Semi (AssignOp [] oper [expr| $$(left).value[$$(i)] |]
[expr| $$(right).value[$$(i)] |]
mempty) mempty

68
generation/src/Conversions.hs
View File

@@ -34,7 +34,7 @@ declareConversions bitsize =
i128_prims = generateI128Primitives sname i128_prims = generateI128Primitives sname
in [sourceFile| in [sourceFile|
use core::convert::{From,TryFrom}; use core::convert::{From,TryFrom};
use core::num::TryFromIntError; use crate::CryptoNum;
#[cfg(test)] #[cfg(test)]
use quickcheck::quickcheck; use quickcheck::quickcheck;
use super::$$sname; use super::$$sname;
@@ -57,9 +57,9 @@ generateU128Primitives :: Ident -> Word -> [Item Span]
generateU128Primitives sname entries = [ generateU128Primitives sname entries = [
[item|impl From<u128> for $$sname { [item|impl From<u128> for $$sname {
fn from(x: u128) -> Self { fn from(x: u128) -> Self {
let mut res = $$sname::zero; let mut res = $$sname::zero();
res[0] = x as u64; res.value[0] = x as u64;
res[1] = (x >> 64) as u64; res.value[1] = (x >> 64) as u64;
res res
} }
}|] }|]
@@ -67,17 +67,17 @@ generateU128Primitives sname entries = [
type Error = ConversionError; type Error = ConversionError;
fn try_from(x: $$sname) -> Result<u128,ConversionError> { fn try_from(x: $$sname) -> Result<u128,ConversionError> {
let mut goodConversion = true; let mut good_conversion = true;
let mut res = 0; let mut res;
res = (x.values[1] as u128) << 64; res = (x.value[1] as u128) << 64;
res |= x.values[0] as u128; res |= x.value[0] as u128;
$@{testZeros} $@{testZeros}
if goodConversion { if good_conversion {
Ok(res) Ok(res)
} else { } else {
Err(ConversionError::Overflow); Err(ConversionError::Overflow)
} }
} }
}|] }|]
@@ -85,17 +85,17 @@ generateU128Primitives sname entries = [
type Error = ConversionError; type Error = ConversionError;
fn try_from(x: &$$sname) -> Result<u128,ConversionError> { fn try_from(x: &$$sname) -> Result<u128,ConversionError> {
let mut goodConversion = true; let mut good_conversion = true;
let mut res = 0; let mut res;
res = (x.values[1] as u128) << 64; res = (x.value[1] as u128) << 64;
res |= x.values[0] as u128; res |= x.value[0] as u128;
$@{testZeros} $@{testZeros}
if goodConversion { if good_conversion {
Ok(res) Ok(res)
} else { } else {
Err(ConversionError::Overflow()); Err(ConversionError::Overflow)
} }
} }
}|] }|]
@@ -103,14 +103,14 @@ generateU128Primitives sname entries = [
where where
testZeros = map (zeroTest . toLit) [2..entries-1] testZeros = map (zeroTest . toLit) [2..entries-1]
zeroTest i = zeroTest i =
[stmt| goodConversion &= x.values[$$(i)] == 0; |] [stmt| good_conversion &= x.value[$$(i)] == 0; |]
buildPrimitives :: Ident -> Ident -> Word -> [Item Span] buildPrimitives :: Ident -> Ident -> Word -> [Item Span]
buildPrimitives sname tname entries = [ buildPrimitives sname tname entries = [
[item|impl From<$$tname> for $$sname { [item|impl From<$$tname> for $$sname {
fn from(x: $$tname) -> Self { fn from(x: $$tname) -> Self {
let mut res = $$sname::zero(); let mut res = $$sname::zero();
res.values[0] = x as u64; res.value[0] = x as u64;
res res
} }
}|] }|]
@@ -118,13 +118,11 @@ buildPrimitives sname tname entries = [
type Error = ConversionError; type Error = ConversionError;
fn try_from(x: $$sname) -> Result<Self,ConversionError> { fn try_from(x: $$sname) -> Result<Self,ConversionError> {
let mut goodConversion = true; let mut good_conversion = true;
let mut res = 0; let res = x.value[0] as $$tname;
res = x.values[0] as $$tname;
$@{testZeros} $@{testZeros}
if goodConversion { if good_conversion {
Ok(res) Ok(res)
} else { } else {
Err(ConversionError::Overflow) Err(ConversionError::Overflow)
@@ -135,13 +133,11 @@ buildPrimitives sname tname entries = [
type Error = ConversionError; type Error = ConversionError;
fn try_from(x: &$$sname) -> Result<Self,ConversionError> { fn try_from(x: &$$sname) -> Result<Self,ConversionError> {
let mut goodConversion = true; let mut good_conversion = true;
let mut res = 0; let res = x.value[0] as $$tname;
res = x.values[0] as $$tname;
$@{testZeros} $@{testZeros}
if goodConversion { if good_conversion {
Ok(res) Ok(res)
} else { } else {
Err(ConversionError::Overflow) Err(ConversionError::Overflow)
@@ -152,7 +148,7 @@ buildPrimitives sname tname entries = [
where where
testZeros = map (zeroTest . toLit) [1..entries-1] testZeros = map (zeroTest . toLit) [1..entries-1]
zeroTest i = zeroTest i =
[stmt| goodConversion &= x.values[$$(i)] == 0; |] [stmt| good_conversion &= x.value[$$(i)] == 0; |]
generateSignedPrims :: Ident -> Ident -> Ident -> [Item Span] generateSignedPrims :: Ident -> Ident -> Ident -> [Item Span]
generateSignedPrims sname unsigned signed = [ generateSignedPrims sname unsigned signed = [
@@ -161,7 +157,7 @@ generateSignedPrims sname unsigned signed = [
fn try_from(x: $$signed) -> Result<Self,ConversionError> { fn try_from(x: $$signed) -> Result<Self,ConversionError> {
let mut res = $$sname::zero(); let mut res = $$sname::zero();
res.values[0] = x as u64; res.value[0] = x as u64;
if x < 0 { if x < 0 {
Err(ConversionError::NegativeToUnsigned) Err(ConversionError::NegativeToUnsigned)
} else { } else {
@@ -173,7 +169,7 @@ generateSignedPrims sname unsigned signed = [
type Error = ConversionError; type Error = ConversionError;
fn try_from(x: $$sname) -> Result<Self,ConversionError> { fn try_from(x: $$sname) -> Result<Self,ConversionError> {
let uns = $$unsigned::from(x)?; let uns = $$unsigned::try_from(x)?;
Ok($$signed::try_from(uns)?) Ok($$signed::try_from(uns)?)
} }
}|] }|]
@@ -181,7 +177,7 @@ generateSignedPrims sname unsigned signed = [
type Error = ConversionError; type Error = ConversionError;
fn try_from(x: &$$sname) -> Result<Self,ConversionError> { fn try_from(x: &$$sname) -> Result<Self,ConversionError> {
let uns = $$unsigned::from(x)?; let uns = $$unsigned::try_from(x)?;
Ok($$signed::try_from(uns)?) Ok($$signed::try_from(uns)?)
} }
}|] }|]
@@ -194,8 +190,8 @@ generateI128Primitives sname = [
fn try_from(x: i128) -> Result<Self,ConversionError> { fn try_from(x: i128) -> Result<Self,ConversionError> {
let mut res = $$sname::zero(); let mut res = $$sname::zero();
res.values[0] = x as u64; res.value[0] = x as u64;
res.values[1] = ((x as u128) >> 64) as u64; res.value[1] = ((x as u128) >> 64) as u64;
if x < 0 { if x < 0 {
Err(ConversionError::NegativeToUnsigned) Err(ConversionError::NegativeToUnsigned)
} else { } else {
@@ -207,7 +203,7 @@ generateI128Primitives sname = [
type Error = ConversionError; type Error = ConversionError;
fn try_from(x: $$sname) -> Result<Self,ConversionError> { fn try_from(x: $$sname) -> Result<Self,ConversionError> {
let uns = u128::from(x)?; let uns = u128::try_from(x)?;
Ok(i128::try_from(uns)?) Ok(i128::try_from(uns)?)
} }
}|] }|]
@@ -215,7 +211,7 @@ generateI128Primitives sname = [
type Error = ConversionError; type Error = ConversionError;
fn try_from(x: &$$sname) -> Result<Self,ConversionError> { fn try_from(x: &$$sname) -> Result<Self,ConversionError> {
let uns = u128::from(x)?; let uns = u128::try_from(x)?;
Ok(i128::try_from(uns)?) Ok(i128::try_from(uns)?)
} }
}|] }|]

10
generation/src/CryptoNum.hs
View File

@@ -27,7 +27,7 @@ declareCryptoNumInstance bitsize =
bitlength = toLit bitsize bitlength = toLit bitsize
bytelen = bitsize `div` 8 bytelen = bitsize `div` 8
bytelenlit = toLit bytelen bytelenlit = toLit bytelen
bytebuffer = Delimited mempty Brace (Stream [ bytebuffer = Delimited mempty Bracket (Stream [
Tree (Token mempty (LiteralTok (IntegerTok "0") Nothing)), Tree (Token mempty (LiteralTok (IntegerTok "0") Nothing)),
Tree (Token mempty Semicolon), Tree (Token mempty Semicolon),
Tree (Token mempty (LiteralTok (IntegerTok (show bytelen)) Nothing)) Tree (Token mempty (LiteralTok (IntegerTok (show bytelen)) Nothing))
@@ -54,7 +54,7 @@ declareCryptoNumInstance bitsize =
fn is_even(&self) -> bool { fn is_even(&self) -> bool {
self.value[0] & 0x1 == 0 self.value[0] & 0x1 == 0
} }
fn is_off(&self) -> bool { fn is_odd(&self) -> bool {
self.value[0] & 0x1 == 1 self.value[0] & 0x1 == 1
} }
fn bit_length() -> usize { fn bit_length() -> usize {
@@ -100,8 +100,8 @@ declareCryptoNumInstance bitsize =
let mut idx = 0; let mut idx = 0;
let mut shift = 0; let mut shift = 0;
for x in bytes.iter_mut().take($$(bytelenlit)).reverse() { for x in bytes.iter_mut().take($$(bytelenlit)).rev() {
*x = (self.values[idx] >> shift) as u8; *x = (self.value[idx] >> shift) as u8;
shift += 8; shift += 8;
if shift == 64 { if shift == 64 {
idx += 1; idx += 1;
@@ -143,5 +143,5 @@ generateZeroTests i entries
| i == entries = [] | i == entries = []
| otherwise = | otherwise =
let ilit = toLit i let ilit = toLit i
in [stmt| result = self.values[$$(ilit)] == 0; |] : in [stmt| result &= self.value[$$(ilit)] == 0; |] :
generateZeroTests (i + 1) entries generateZeroTests (i + 1) entries

8
generation/src/Main.hs
View File

@@ -9,11 +9,12 @@ import CryptoNum(cryptoNum)
import Control.Monad(forM_,unless) import Control.Monad(forM_,unless)
import Data.Maybe(mapMaybe) import Data.Maybe(mapMaybe)
import File(File,Task(..),addModuleTasks,makeTask) import File(File,Task(..),addModuleTasks,makeTask)
import Language.Rust.Pretty(prettyAnnotated') import Language.Rust.Pretty(writeSourceFile)
import System.Directory(createDirectoryIfMissing) import System.Directory(createDirectoryIfMissing)
import System.Environment(getArgs) import System.Environment(getArgs)
import System.Exit(die) import System.Exit(die)
import System.FilePath(takeDirectory,(</>)) import System.FilePath(takeDirectory,(</>))
import System.IO(IOMode(..),hPutStrLn,withFile)
lowestBitsize :: Word lowestBitsize :: Word
lowestBitsize = 192 lowestBitsize = 192
@@ -56,4 +57,7 @@ main =
forM_ (zip [(1::Word)..] tasks) $ \ (i, task) -> forM_ (zip [(1::Word)..] tasks) $ \ (i, task) ->
do putStrLn ("[" ++ show i ++ "/" ++ show total ++ "] " ++ outputFile task) do putStrLn ("[" ++ show i ++ "/" ++ show total ++ "] " ++ outputFile task)
createDirectoryIfMissing True (takeDirectory (outputFile task)) createDirectoryIfMissing True (takeDirectory (outputFile task))
writeFile (outputFile task) (show (prettyAnnotated' (fileData task))) withFile (outputFile task) WriteMode $ \ targetHandle ->
do hPutStrLn targetHandle
"// WARNING: This file was automatically generated. Do not edit!"
writeSourceFile targetHandle (fileData task)