add public modifier and getter function

.gitignore

+test.sol
\ No newline at end of file

Auction.sol

 pragma solidity ^0.4.4;
-contract DAuction {
+contract Auction {
 	
-	uint256 minimumPrice;  
-	uint256 biddingBlocksNum;  
+	uint256 public minimumPrice;  
+	uint256 public biddingBlocksNum;  
 	address judgeAddr;
-	uint256 startBlockNum;
-	address creator;
+	uint256 public startBlockNum;
+	address public creator;
 
 	address highestBidder;
 	uint256 highestBid;
 	
 
 	// constructor
-	function DAuction(uint256 reservePrice, uint256 biddingTimePeriod, address judgeAddress) {
+	function Auction(uint256 reservePrice, uint256 biddingTimePeriod, address judgeAddress) {
 		minimumPrice = reservePrice;
-		blocksNum = biddingTimePeriod;
+		biddingBlocksNum = biddingTimePeriod;
 		judgeAddr = judgeAddress;
 		startBlockNum = block.number; 
 		creator = msg.sender;
 	}
 
 	// Three types of bidding functions. If not overriden, these generate errors
-	function bid() biddingOpen payable {
-		throw;
+	function bid() biddingOpen payable returns(address) {
+		require(false);
 	}
 
 	function commitBid(bytes32 bidCommitment) biddingOpen payable returns(bool) {
-		throw;
+		require(false);
 	}
 
-	function revealBid(uint256 nonce) payable returns(address highestBidder) {
-		throw;
+	function revealBid(uint256 nonce) payable returns(address) {
+		require(false);
 	}
 
 	function finalize() auctionOver {
-		throw;
+		require(false);
 	}
 
 	
 	function refund(uint256 refundAmount) auctionOver judgeOnly {
-		throw;
+		require(false);
 	}
 
 	modifier biddingOpen {
-		throw;
+		require(false);
 		_;
 	}
 
 	modifier auctionOver {
-		throw;
+		require(false);
 		_;
 	}
 
 	modifier judgeOnly {
-		require(msg.sender == judgeAddress);
+		require(msg.sender == judgeAddr);
 		_;
 	}
 

Auctions.sol

 pragma solidity ^0.4.4;
-import "DAuction.sol";
-import "DVickreyAuction.sol";
-import "DDutchAuction.sol";
-import "DEnglishAuction.sol";
+import "Auction.sol";
+import "VickreyAuction.sol";
+import "DutchAuction.sol";
+import "EnglishAuction.sol";
 
-//This code is provided for you. You can modify if you want to for debugging, but you shouldn't need to put any logic here.
-contract DAuctions {
+contract Auctions {
 
-    mapping(uint256 => DAuction) auctions;
+    mapping(uint256 => Auction) auctions;
     uint256 numAuctions;
 
     // This function is used for testing
@@ -17,39 +16,21 @@ contract DAuctions {
     
     function beginDutchAuction(uint256 reservePrice, address judgeAddress, uint256 biddingTimePeriod, uint256 offerPriceDecrement) returns(uint256 auctionID) {
         auctionID = numAuctions++;
-        auctions[auctionID] = new DDutchAuction(reservePrice, judgeAddress, biddingTimePeriod, offerPriceDecrement);
+        auctions[auctionID] = new DutchAuction(reservePrice, judgeAddress, biddingTimePeriod, offerPriceDecrement);
         return auctionID;
     }
 
     function beginEnglishAuction(uint256 reservePrice, address judgeAddress, uint256 biddingTimePeriod, uint256 minBidIncrement) returns(uint256 auctionID) {
         auctionID = numAuctions++;
-        auctions[auctionID] = new DEnglishAuction(reservePrice, judgeAddress, biddingTimePeriod, minBidIncrement);
+        auctions[auctionID] = new EnglishAuction(reservePrice, judgeAddress, biddingTimePeriod, minBidIncrement);
         return auctionID;
     }
 
     function beginVickreyAuction(uint256 reservePrice, address judgeAddress, uint256 commitTimePeriod, uint256 revealTimePeriod, uint256 bidDepositAmount) returns(uint256 auctionID) {
         auctionID = numAuctions++;
-        auctions[auctionID] = new DVickreyAuction(reservePrice, judgeAddress, commitTimePeriod, revealTimePeriod, bidDepositAmount);
+        auctions[auctionID] = new VickreyAuction(reservePrice, judgeAddress, commitTimePeriod, revealTimePeriod, bidDepositAmount);
         return auctionID;
     }
 
-    function bid(uint256 id) payable returns(address) {
-        return auctions[id].bid.value(msg.value)();
-    }
-
-    function finalize(uint256 id) {
-        auctions[id].finalize();
-    }
-
-    function refund(uint256 id, uint256 amount) {
-        auctions[id].refund(amount);
-    }
-
-    function revealBid(uint256 id, uint256 nonce) payable returns(address) {
-        return auctions[id].revealBid.value(msg.value)(nonce);
-    }
-
-    function commitBid(uint256 id, bytes32 bidCommitment) payable returns(bool) {
-        return auctions[id].commitBid.value(msg.value)(bidCommitment);
-    }
+    // you bid directly to the contract
 }

DutchAuction.sol

 pragma solidity ^0.4.4;
-import "DAuction.sol";
-contract DDutchAuction is DAuction {
+import "Auction.sol";
+contract DutchAuction is Auction {
 
-	uint256 decrementPerBlock;
-	bool bidover;
-	uint256 startPrice;
+	uint256 public decrementPerBlock;
+	bool public bidover;
+	uint256 public startPrice;
 	bool refundCalled;
 	bool finalizeCalled;
 
-
-
 	// constructor
-	function DDutchAuction(uint256 reservePrice, address judgeAddress, uint256 biddingPeriod, uint256 offerPriceDecrement) DAuction(reservePrice, biddingPeriod, judgeAddress) {
+	function DutchAuction(uint256 reservePrice, address judgeAddress, uint256 biddingPeriod, uint256 offerPriceDecrement) Auction(reservePrice, biddingPeriod, judgeAddress) {
 	    decrementPerBlock = offerPriceDecrement;
 	    startPrice = reservePrice+biddingPeriod*offerPriceDecrement;
 	}
@@ -25,15 +23,13 @@ contract DDutchAuction is DAuction {
 		return highestBidder;
 	}
 
-
 	function finalize(){
-		require(msg.sender==highestBidder || msg.sender = judgeAddress);
+		require(msg.sender==highestBidder || msg.sender == judgeAddr);
 		require(!refundCalled && !finalizeCalled);
-		finalizeCalled=truel
+		finalizeCalled=true;
 		creator.transfer(highestBid);
 	}
 
-
 	function refund(uint256 refundAmount) auctionOver judgeOnly {
 		require(highestBidder!=0);
 		require(refundAmount<= this.balance);

EnglishAuction.sol

 pragma solidity ^0.4.4;
-import "DAuction.sol";
+import "Auction.sol";
 
-contract DEnglishAuction is DAuction {
+contract EnglishAuction is Auction {
 
-	uint256 minBidIncrement;
-	uint numUnchallengedBlocks;
-	uint lastBidBlock;
+	uint256 public minBidIncrement;
+	uint public numUnchallengedBlocks;
+	uint public lastBidBlock;
 
-	mapping (address => uint) PendingWithdrawals;
+	mapping (address => uint) public PendingWithdrawals;
 	bool refundCalled;
-	bool finalizeCalle
+	bool finalizeCalled;
 
     // constructor
-    function DEnglishAuction(uint256 reservePrice, address judgeAddress, uint256 biddingTimePeriod, uint256 minBidIncrement) DAuction(reservePrice, biddingTimePeriod, judgeAddress) {
-        this.minBidIncrement = minBidIncrement;
+    function EnglishAuction(uint256 reservePrice, address judgeAddress, uint256 biddingTimePeriod, uint256 minimumBidIncrement) Auction(reservePrice, biddingTimePeriod, judgeAddress) {
+        minBidIncrement = minimumBidIncrement;
         numUnchallengedBlocks = 3;
     }
 
@@ -31,10 +31,8 @@ contract DEnglishAuction is DAuction {
     	return highestBidder;
     }    
 
-    
-
     function finalize() auctionOver {
-    	require(msg.sender==highestBidder || msg.sender = judgeAddress);
+    	require(msg.sender==highestBidder || msg.sender == judgeAddr);
     	require(!refundCalled && !finalizeCalled);
     	finalizeCalled=true;
     	creator.transfer(highestBid);
@@ -50,7 +48,7 @@ contract DEnglishAuction is DAuction {
     }
 
     function withdraw(){
-    	int amount = PendingWithdrawals[msg.sender];
+    	uint amount = PendingWithdrawals[msg.sender];
     	PendingWithdrawals[msg.sender]=0;
     	if(amount>0){
     		msg.sender.transfer(amount);

VickreyAuction.sol

 pragma solidity ^0.4.4;
-import "DAuction.sol";
+import "Auction.sol";
 
-contract DVickreyAuction is DAuction {
+contract VickreyAuction is Auction {
 
 	uint256 public bidDepositAmount;
 	uint256 public revealBlocksNum;
@@ -15,18 +15,17 @@ contract DVickreyAuction is DAuction {
 	mapping ( address => uint ) bidAmount;
 
 	// constructor
-	function DVickreyAuction(uint256 reservePrice, address judgeAddress, uint256 commitTimePeriod, uint256 revealTimePeriod, uint256 _bidDepositAmount) DAuction(reservePrice, commitTimePeriod, judgeAddress) {
+	function VickreyAuction(uint256 reservePrice, address judgeAddress, uint256 commitTimePeriod, uint256 revealTimePeriod, uint256 _bidDepositAmount) Auction(reservePrice, commitTimePeriod, judgeAddress) {
 		bidDepositAmount = _bidDepositAmount;
-		revealBlockNum = revealTimePeriod; 
+		revealBlocksNum = revealTimePeriod; 
 	}
 
 	function commitBid(bytes32 bidCommitment) biddingOpen payable returns(bool) {
 		require(msg.value == bidDepositAmount);
-		deposits[msg.sender][bidCommitment]+=msg.value;
+		deposits[msg.sender][bidCommitment]+=1;
 		return true;
 	}
 
-
 	function revealBid(uint256 nonce) revealOpen payable returns(address highestBidder) {
 		bytes32 commitval = sha3(nonce,msg.value);
 		require(deposits[msg.sender][commitval]>0);
@@ -42,11 +41,11 @@ contract DVickreyAuction is DAuction {
 			}
 		}
 		msg.sender.transfer(bidDepositAmount);
-		returns highestBidder;
+		return highestBidder;
 	}
 
 	function finalize() auctionover {
-		require(msg.sender == highestBidder);
+		require(msg.sender == highestBidder || msg.sender == judgeAddr);
 		require(!refundCalled && !finalizeCalled);
 		finalizeCalled=true;
 		if(secondHighestBid==0 && highestBid!=0){
@@ -64,7 +63,7 @@ contract DVickreyAuction is DAuction {
 		highestBidder.transfer(refundAmount);
 		if(secondHighestBid==0 && highestBid>0){
 			if(minimumPrice>refundAmount)
-				creator.transfer(minimumPrice-refundAmount)
+				creator.transfer(minimumPrice-refundAmount);
 		}else if (secondHighestBid>refundAmount)
 			creator.transfer(secondHighestBid-refundAmount);
 	}
@@ -87,18 +86,18 @@ contract DVickreyAuction is DAuction {
 	}
 
 	modifier auctionover {
-		require(block.blockNum > startBlockNum+biddingBlocksNum+revealBlocksNum);
+		require(block.number > startBlockNum+biddingBlocksNum+revealBlocksNum);
 		_;
 	}
 
 	modifier biddingOpen {
-		require(block.blockNum <= startBlockNum+biddingBlocksNum);
+		require(block.number <= startBlockNum+biddingBlocksNum);
 		_;
 	}
 
 	modifier revealOpen {
-		require(block.blockNum > startBlockNum+biddingBlocksNum);
-		require(block.blockNum <= startBlockNum+biddingBlocksNum+revealBlocksNum);
+		require(block.number > startBlockNum+biddingBlocksNum);
+		require(block.number <= startBlockNum+biddingBlocksNum+revealBlocksNum);
 		_;
 	}