The last line (line 247) in my ERC-20 code has a “ParserError: Expected Pragma, import directive or contract interface”. How do I solve this?

Question

What measures do I take to solve this? I am currently on Compiler version 0.4.24 and this error shows up multiple times in my code which I solved by inserting a bracket. Now it is at the end of the code and I am not sure what to do. Please help, thanks.

{ 
              pragma solidity ^0.4.24;


              contract owned {
              address public owner;

              function owned() public {
              owner = msg.sender;
              }

           modifier onlyOwner {
           require(msg.sender == owner);
                               _;
         }
           function transferOwnership(address newOwner) onlyOwner public {
    owner = newOwner;
}


    interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }

   contract TheJEFF {
// Public variables of the token
string public name;
string public symbol; 
uint8 public decimals = 3;
uint256 public totalSupply; 

// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;

//This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);

//This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);

/**
 * Constrctor function
 * 
 * Intializes contract with initial supply tokens to the creator of the contract
 * */
 function TheJEFF(
     uint256intialSupply,
     string tokenName,
     string tokenSymbol
) public {
    totalSupply = intialSupply *50000000.000** uint256(3);
    balanceOf [msg.sender] = totalSupply;
    name = "TheJEFF";
    symbol = "GXAU";
}
   /**
   * Internal transfer, only can be called by this contract
 */
function _transfer(address _from, address _to, uint _value) internal {
    // Prevent transfer to 0x0 address. Use burn() instead
    require(_to != 0x0);
    // Check if the sender has enough
    require(balanceOf[_from] >= _value);
    // Check for overflows
    require(balanceOf[_to] + _value > balanceOf[_to]);
    // Save this for an assertion in the future
    uint previousBalances = balanceOf[_from] + balanceOf[_to];
    // Subtract from the sender
    balanceOf[_from] -= _value;
    // Add the same to the recipient
    balanceOf[_to] += _value;
    emit Transfer (_from, _to, _value);
    // Asserts are used to use static analysis to find bugs in your code. They should never fail
    assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}


/**
 * Transfer tokens
 *
 * Send `_value` tokens to `_to` from your account
 *
 * @param _to The address of the recipient
 * @param _value the amount to send
 */
function transfer(address _to, uint256 _value) public returns (bool success) {
    _transfer(msg.sender, _to, _value);
    return true;
}

/**
 * Transfer tokens from other address
 *
 * Send `_value` tokens to `_to` in behalf of `_from`
 *
 * @param _from The address of the sender
 * @param _to The address of the recipient
 * @param _value the amount to send
 */
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
    require(_value <= allowance[_from][msg.sender]);     // Check allowance
    allowance[_from][msg.sender] -= _value;
    _transfer(_from, _to, _value);
    return true;
}

/**
 * Set allowance for other address
 *
 * Allows `_spender` to spend no more than `_value` tokens in your behalf
 *
 * @param _spender The address authorized to spend
 * @param _value the max amount they can spend
 */
function approve(address _spender, uint256 _value) public
    returns (bool success) {
    allowance[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
}

/**
 * Set allowance for other address and notify
 *
 * Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
 *
 * @param _spender The address authorized to spend
 * @param _value the max amount they can spend
 * @param _extraData some extra information to send to the approved contract
 */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
    public
    returns (bool success) {
    tokenRecipient spender = tokenRecipient(_spender);
    if (approve(_spender, _value)) {
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }
    }
   /**
 * Destroy tokens
 * Remove value from the system irreversibly
 * 
 */
  function burnFrom(address _from, uint256 _value) public returns (bool success) 
 {
    require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
    require(_value <= allowance[_from][msg.sender]);    // Check allowance
    balanceOf[_from] -= _value;                         // Subtract from the targeted balance
    allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
    totalSupply -= _value;                              // Update totalSupply
    emit Burn(_from, _value);
    return true;
}
}


  contract TheJEFF is owned, TokenERC20 {
    uint256 public sellPrice;
    uint256 public buyPrice;

    mapping (address => bool) public frozenAccount;
     /*This generates a public event on the blockchain that will notify clients*/
      event FrozenFunds(address target, bool frozen);

       /*Initializes contract with initial supply tokens to the creator of the contract */
function TheGoldmoneyToken(
uint256 initialSupply, 
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public{}

/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address_to, uint_value) internal {
    require (_to != 0x0);                       // Prevent transfer to OxO address. Use burn() instead
    require (balanceOf[_from]>= _value);        // Check if sender has enough
    require (balanceOf[_to] + _value >= balanceof[_to]); // Check for overflows
    require(!frozenAccount[_from]);             // Check if sender is frozen
    require(!frozenAccount[_to]);               // Check if recipient is frozen
    balanceOf[_from] -= _value;                 // Subtract from the sender
    balanceOf[_to] += -value;                   // Add the same to the recipient
    emit Transfer (_from, _to, _value);         
   }

     ///Create 'mintedAmount' tokens and send it to 'target'
     ///@param target address to receive tokens
     ///@param mintedAmount the amount of tokens it will receive
     function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
     }

      ///@notice 'freeze?' Prevent| Allow 'target' from sending & receiving tokens
      ///@param target Address to be frozen
      ///@param freeze either to freeze it or not

      function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
    }

     function transfer (address _to, uint256 _value) {
require(!frozenAccount[msg.sender]);
require(approvedAccount[msg.sender]);
      }

        //*Allow token to automatically detect and refill user balance if balance is too low to pay for Ether blockchain transaction cost*//

     uint public minBalanceForAccounts;

    function setMinBalance(uint minimumBalanceInFinney) onlyOwner {
minBalanceForAccounts = minimumBalanceInFinney * 10 finney;
      }

      /*Send coins*/
      //If the sender does not meet minimum requirement, this allows them to be refunded
     function transfer(address _to, uint256 _value) {
if(msg.sender.balance < minBalanceForAccounts)
    sell((minBalanceForAccounts - msg.sender.balance)/ sellPrice);
     }

     ///@notice Allow users to buy tokens for 'newBuyPrice' eth and sell tokens for 'newSellPrice' eth
    ///@param newSellPrice Price users can buy from the contract
    ///@param newBuyPrice Price users can buy from the contract
     function setPrices (uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
     }

     /// @notice Buy tokens from contract by sending ether 
     function buy() payable public {
uint amount = msg.value / buyPrice;                 //calculates the amount
_transfer(this, msg.sender, amount);                //makes the transfers
     }

     ///@notice Sell 'amount' tokens to contract
     ///@param amount of tokens to be sold
     function sell(uint256 amount) public {
address myAddress = this;
require(myAddress.balance >= amount * sellPrice);    //checks if contract has enough ether to buy
_transfer(msg.sender, this, amount);                //makes the transfers
msg.sender.transfer(amount * sellPrice);            //sends ether to the seller
    }
    }

   }

Answer 1

why do you have an opening curly brace before the "pragma solidity ^0.4.24;" line? it's supposed to be the first line in the entire program. So first you delete the first opening curly brace, so your code changes from

{ 
              pragma solidity ^0.4.24;


              contract owned {
...

to

pragma solidity ^0.4.24;


              contract owned {
...

make sure the ENTIRE file starts with the "pragma solidity ^0.4.24;" line, that way the "ParserError: Expected Pragma, import directive or contract interface" error will go away, and then you can see if there are any other issues with your code.

Answer 2

Do format your code with correct indentation.

1)There is an opening brace at the top - start of the code.
2) Your owned contract is not closed with closing brace.
3) Multiple contracts with same name - TheJEFF
4) variable not well defined uint256initialSupply
5) TokenERC20 not defined