local parentShell = shell

local bExit = false
local sDir = (parentShell and parentShell.dir and parentShell.dir()) or ""
local sPath = (parentShell and parentShell.path and parentShell.path()) or ".:/rom/programs"
local tAliases = (parentShell and parentShell.aliases and parentShell.aliases()) or {}
local tProgramStack = {}

local bClock = true

local saveDir= (parentShell and parentShell.getRunningProgram and parentShell.getRunningProgram()) or "/" 
saveDir=string.sub(saveDir,1,#saveDir-#fs.getName(saveDir))
if fs.isReadOnly(saveDir) then saveDir="/" end


local shell = {}
local tEnv = {
	["shell"] = shell
}

--[[ Colours  --]]
local promptColour, textColour, bgColour
if term.isColour() then
	promptColour = colours.yellow
	textColour = colours.white
	bgColour = colours.black
else
	promptColour = colours.white
	textColour = colours.white
	bgColour = colours.black
end

--[[ Standard Shell Functions --]]

local function run( _sCommand, ... )
	local sPath = shell.resolveProgram( _sCommand )
	if sPath ~= nil then
		tProgramStack[#tProgramStack + 1] = sPath
   		local result = os.run( tEnv, sPath, ... )
		tProgramStack[#tProgramStack] = nil
		return result
   	else
    	printError( "No such program" )
    	return false
    end
end

local function runLine( _sLine )
	local tWords = {}
	for match in string.gmatch( _sLine, "[^ \t]+" ) do
		table.insert( tWords, match )
	end
	local sCommand = tWords[1]
	if sCommand then
		return run( sCommand, unpack( tWords, 2 ) )
	end
	return false
end

--[[ Install shell API  --]]
function shell.run( ... )
	return runLine(table.concat( { ... }, " " ))
end

function shell.exit()
    bExit = true
end

function shell.dir()
	return sDir
end

function shell.setDir( _sDir )
	sDir = _sDir
end

function shell.path()
	return sPath
end

function shell.setPath( _sPath )
	sPath = _sPath
end

function shell.resolve( _sPath )
	local sStartChar = string.sub( _sPath, 1, 1 )
	if sStartChar == "/" or sStartChar == "\\" then
		return fs.combine( "", _sPath )
	else
		return fs.combine( sDir, _sPath )
	end
end

function shell.resolveProgram( _sCommand )
	--[[ Substitute aliases firsts  --]]
	if tAliases[ _sCommand ] ~= nil then
		_sCommand = tAliases[ _sCommand ]
	end

    --[[ If the path is a global path, use it directly  --]]
    local sStartChar = string.sub( _sCommand, 1, 1 )
    if sStartChar == "/" or sStartChar == "\\" then
    	local sPath = fs.combine( "", _sCommand )
    	if fs.exists( sPath ) and not fs.isDir( sPath ) then
			return sPath
    	end
		return nil
    end
	
	--[[  Otherwise, look on the path variable  --]]
    for sPath in string.gmatch(sPath, "[^:]+") do
    	sPath = fs.combine( shell.resolve( sPath ), _sCommand )
    	if fs.exists( sPath ) and not fs.isDir( sPath ) then
			return sPath
    	end
    end
	
	--[[ Not found  --]]
	return nil
end

function shell.programs( _bIncludeHidden )
	local tItems = {}
	
	--[[ Add programs from the path  --]]
    for sPath in string.gmatch(sPath, "[^:]+") do
    	sPath = shell.resolve( sPath )
		if fs.isDir( sPath ) then
			local tList = fs.list( sPath )
			for n,sFile in pairs( tList ) do
				if not fs.isDir( fs.combine( sPath, sFile ) ) and
				   (_bIncludeHidden or string.sub( sFile, 1, 1 ) ~= ".") then
					tItems[ sFile ] = true
				end
			end
		end
    end	

	--[[ Sort and return  --]]
	local tItemList = {}
	for sItem, b in pairs( tItems ) do
		table.insert( tItemList, sItem )
	end
	table.sort( tItemList )
	return tItemList
end

function shell.getRunningProgram()
	if #tProgramStack > 0 then
		return tProgramStack[#tProgramStack]
	end
	return nil
end

function shell.setAlias( _sCommand, _sProgram )
	tAliases[ _sCommand ] = _sProgram
end

function shell.clearAlias( _sCommand )
	tAliases[ _sCommand ] = nil
end

function shell.aliases()
	--[[ Add aliases  --]]
	local tCopy = {}
	for sAlias, sCommand in pairs( tAliases ) do
		tCopy[sAlias] = sCommand
	end
	return tCopy
end


--[[ My Functions --]] --[[ My Functions --]] --[[ My Functions --]]

--[[ File Useage --]]
local function save(A,B) local file = fs.open(tostring(A),"w") file.write(B) file.close() end
local function saveT(A,B) save(A,textutils.serialize(B)) end
local function saveTH(A,B) save(A,string.gsub(textutils.serialize(B),"},","},\r\n")) end
local function get(A) local file = fs.open(tostring(A),"r") if not file then return false end local data = file.readAll() file.close() if data then return data end end
local function getT(A) local data = get(A) if data then data = textutils.unserialize(data) end if data then return data end end

-- pastebin code

local pastebin={
api_user_key = false,
api_dev_key="6ee24782806f592dc9b3be30960fe117",
login=function(api_user_name,api_user_password)
	handle=http.post("http://pastebin.com/api/api_login.php","api_user_name="..textutils.urlEncode(api_user_name).."&api_user_password="..textutils.urlEncode(api_user_password).."&api_dev_key="..textutils.urlEncode(pastebin.api_dev_key))
	local out=handle.readAll()
	handle.close()
	return out
end,
listall=function()
	handle=http.post("http://pastebin.com/api/api_post.php","api_user_key="..textutils.urlEncode(pastebin.api_user_key).."&api_results_limit="..textutils.urlEncode(tostring(1000)).."&api_dev_key="..textutils.urlEncode(pastebin.api_dev_key).."&api_option=list")
	local out=handle.readAll()
	handle.close()
	return out
end,
user=function()
	handle=http.post("http://pastebin.com/api/api_post.php","api_user_key="..textutils.urlEncode(pastebin.api_user_key).."&api_dev_key="..textutils.urlEncode(pastebin.api_dev_key).."&api_option=userdetails")
	local out=handle.readAll()
	handle.close()
	return out
end,
tabulate=function(A)
    local out = {}
    for i, k in string.gmatch(A, "<(.-)>(.-)</%1>") do
        local temp = {}
        for j, l in string.gmatch(k, "<"..i.."_(.-)>(.-)</"..i.."_%1>") do
            temp[j] = l
        end
        table.insert(out,temp)
    end
    return out
end,
getone=function(code)
	handle=http.get("http://pastebin.com/raw.php?i="..code)
	if not handle then return nil end
	local out=handle.readAll()
	handle.close()
	return out
end
}

--[[ Read without any writes() - visually conceals leanght of password from wiever --]]
local function saferead()
	term.setCursorBlink( true )
    local sLine = ""
	local nPos = 0
	local w, h = term.getSize()
	local sx, sy = term.getCursorPos()		
	while true do
		local sEvent, param = os.pullEvent()
		if sEvent == "char" then
			sLine = string.sub( sLine, 1, nPos ) .. param .. string.sub( sLine, nPos + 1 )
			nPos = nPos + 1
		elseif sEvent == "key" then
		    if param == keys.enter then
				--[[ Enter --]]
				break
			elseif param == keys.backspace then
				--[[ Backspace --]]
				if nPos > 0 then
					sLine = string.sub( sLine, 1, nPos - 1 ) .. string.sub( sLine, nPos + 1 )
					nPos = nPos - 1		
				end
			end
		end
	end
	term.setCursorBlink( false )
	term.setCursorPos( w + 1, sy )
	print()
	return sLine
end

local function pastelogin()
	if not http then print("Http Api is offline - this will not work. Sorry") return end 
	pcall( function()
		if not pastebin.api_user_key then
			write("Username: ") 
			local a=read()
			write("Password: ")
			--[[ Passowrd is not stored - is used and forgotten --]]
			local response=pastebin.login(a,saferead())
			if string.find(string.lower(response), "bad api request" , 1 , true) then print("Login Unsuccessful") pastebin.api_user_key = false
			else print("Login Successful") pastebin.api_user_key = response end
		else
			print("Already Logged in as "..pastebin.tabulate(pastebin.user())[1]["name"].." Use plogout< to logout if you want to change users.")
		end
	end)
end

local function pastelogout()
	pastebin.api_user_key = false print("Logout Successful")
end

local function pasteget(_Where)
	if not http then print("Http Api is offline - this will not work. Sorry") return end 
	if not pastebin.api_user_key then print(" No user logged in - Please use plogin< to login") return end
	
	pcall( function()
		local dir=fs.combine(saveDir,"Pastes")
		if not _Where and not fs.exisits(dir) then fs.makeDir(dir) end
		
		print("Downloading Filelist")
		local pastes=pastebin.tabulate(pastebin.listall())
		
		for i=#pastes,1,-1 do --[[Removing private Pastes - no way to download them--]]
			if pastes[i].private==2 then table.remove(pastes,i) end
		end
		
		local offset=0
		local selected=1
		local All=false
		
		local function List()
			local x,y=term.getSize()
			term.clear()
			if #pastes > y-1 then offset=math.max(0,math.min(#pastes-(y-1),selected-math.floor((y-1)/2))) else offset=0 end
			for i=1,math.min(y-1,#pastes) do
				term.setCursorPos(1,i)
				if i+offset==selected then
				term.setTextColour(colours.black)
				term.setBackgroundColor(colours.white)
				else
				term.setTextColour(colours.white)
				term.setBackgroundColor(colours.black)
				end
				local temp=pastes[i+offset]
				term.write((temp.private==1 and ". " or "")..(temp.selected and "> " or "")..temp["title"]..(temp.selected and " <" or ""))
			end
			term.setTextColour(colours.white)
			term.setBackgroundColor(colours.black)
			term.setCursorPos(1,y)
		end

		List()
		
		while true do
			if _Where then
			term.write("Up/Down,D-Download")
			else
			term.write("Up/Down,Enter-Sel,D-Download,Tab-D-All")
			end
			event= {os.pullEvent()}
			if event[1]=="key" then
				if event[2]==keys.down then
					selected=math.min(selected+1,#pastes)
					List()
				elseif event[2]==keys.up then
					selected=math.max(selected-1,1)
					List()
				elseif event[2]==keys.d then
					if _Where then pastes[selected]["selected"]=true end
					print()
					print("Downloading Selected")	
					break
				elseif not _Where and (event[2]==keys.numPadEnter or event[2]==keys.enter)then
					pastes[selected]["selected"]=not pastes[selected]["selected"]
					List()
				elseif not _Where and  event[2]==keys.tab then
					print()
					print("Downloading All")
					All=true
					break
				end
			end --if event
		end
		
		term.setTextColour(colours.white)
		term.setBackgroundColor(colours.black)
		
		for _,k in pairs(pastes) do
			if k.selected or All then
				local name=string.gsub(k["title"]," ","_")
				print("Downloading "..name)
				local file =nil
				while true do
					file = getone(k["key"])
					if file then break end
					print("Failed - Retrying in 5 sec")
					sleep(5)
					print("Downloading "..name)
				end
				if _Where then save(_Where,file)
				else save(fs.combine(dir,name),file) end
				print("Finished")
			end
		end
		
		print("Downloaded to ",_Where or dir )
	end)
end

local function pasteput()
	if not http then print("Http Api is offline - this will not work. Sorry") return end 
	--[[To be added at later date--]]
end

-- lua code

local LuatEnv = {}
setmetatable( LuatEnv, { __index = getfenv() } )

local function runlua( _sCommand )
	if not _sCommand then return false end


	local nForcePrint = 0
	local func, e = loadstring( _sCommand, "lua" )
	local func2, e2 = loadstring( "return ".._sCommand, "lua" )
	if not func then
		if func2 then
			func = func2
			e = nil
			nForcePrint = 1
		end
	else
		if func2 then
			func = func2
		end
	end
	
	if func then
        setfenv( func, LuatEnv )
        local tResults = { pcall( function() return func() end ) }
        if tResults[1] then
        	local n = 1
        	while (tResults[n + 1] ~= nil) or (n <= nForcePrint) do
        		print( tostring( tResults[n + 1] ) )
        		n = n + 1
        	end
        else
        	printError( tResults[2] )
        end
    else
    	printError( e )
    end
    
end

-- cat code

local function cat(_Tfiles)
	_,y=term.getSize()
	local out={}
	
	pcall( function()
		for i,k in ipairs(_Tfiles) do
			local path=shell.resolve(k)
			if not fs.exists(path) then print("File "..k.." don't exists") return end
			if fs.isDir(path) then print(k.." is a directory") return end
			local file = fs.open(path, "r")
			table.insert(out,file.readAll())
			file.close()
		end
		textutils.pagedPrint(table.concat(out),y)
	end)
end

-- find code

local function findfile(target,patt)
	if target=="" then print("No target specified") return end
	local matches={}
	target=string.lower(target)
	
	local function process(path)
		local T=fs.list(path)
		for _,k in ipairs(T) do
			local cpath=path.."/"..k
			if string.find(string.lower(k), target , 1 , not patt) then table.insert(matches,cpath) end
			if fs.isDir(cpath) then process(cpath) end
		end
	end
	
	local function list(_Tlist)
		local tFiles = {}
		local tVFiles = {}
		local tDirs = {}
		local tVDirs = {}
		for n, sItem in pairs(_Tlist) do
			if fs.isDir( sItem ) then
				table.insert( tDirs, sItem )
			else
				table.insert( tFiles, sItem )
			end
		end
		table.sort( tDirs ) table.sort( tVDirs ) table.sort( tFiles ) table.sort( tVFiles )
		if term.isColour() then
			textutils.pagedTabulate(colors.green , tDirs , colors.white, tFiles)
		else
			textutils.pagedTabulate(tDirs , tFiles)
		end
	end
	
	pcall( function()
		process("")
		list(matches)
	end)
end

-- read with tab-completition code

local function readtab( _sReplaceChar, _tHistory , _sPrefix)
	term.setCursorBlink( true )

    local sLine = _sPrefix or ""
	local nHistoryPos = nil
	local nPos = string.len(sLine)
    if _sReplaceChar then
		_sReplaceChar = string.sub( _sReplaceChar, 1, 1 )
	end
	
	local w, h = term.getSize()
	local sx, sy = term.getCursorPos()	
	local clocvis
	
	local function shellclock(_clear)
		if  bClock and not _clear and sx+#sLine <= w-7 then
			clocvis=true
			term.setCursorBlink( false )
			local state=textutils.formatTime(os.time(),true)
			while #state<5 do state=" "..state end
			local x=term.getCursorPos()
			term.setCursorPos( w-5, sy )
			term.setTextColour( promptColour )
			write(state)
			term.setTextColour( textColour )
			term.setCursorPos( x, sy )
			term.setCursorBlink( true )
		else
			if clocvis then
				local x=term.getCursorPos()
				term.setCursorBlink( false )
				term.setCursorPos( w-5, sy )
				write("     ")
				term.setCursorPos( x, sy )
				term.setCursorBlink( true )
				clocvis=false			
			end
		end		
	end
	
	local function redraw( _sCustomReplaceChar )
		local nScroll = 0
		if sx + nPos >= w then
			nScroll = (sx + nPos) - w
		end
		shellclock()
		term.setCursorPos( sx, sy )
		local sReplace = _sCustomReplaceChar or _sReplaceChar
		if sReplace then
			term.write( string.rep( sReplace, string.len(sLine) - nScroll ) )
		else
			term.write( string.sub( sLine, nScroll + 1 ) )
		end
		term.setCursorPos( sx + nPos - nScroll, sy )
	end

	local function list(_Tlist,_Spath,_Bhide)
		shellclock(true)
		local tFiles = {}
		local tVFiles = {}
		local tDirs = {}
		local tVDirs = {}
		for n, sItem in pairs(_Tlist) do
			if not (_Bhide and string.sub( sItem, 1, 1 )==".") then
				local sPath = fs.combine( _Spath, sItem )
				if fs.isDir( sPath ) then
					table.insert( tDirs, sItem )
				else
					table.insert( tFiles, sItem )
				end
			end
		end
		table.sort( tDirs ) table.sort( tVDirs ) table.sort( tFiles ) table.sort( tVFiles )
		print()
		if term.isColour() then
			pcall( function()
			textutils.pagedTabulate( colors.green , tDirs , colors.white, tFiles)
			end)
		else
			pcall( function()
			textutils.pagedTabulate( tDirs , tFiles)
			end)
		end
		term.setTextColour( promptColour )
		write( shell.dir() .. "> " )
		term.setTextColour( textColour )
		sx, sy = term.getCursorPos()
	end
	
	local function common(_String,_Min,_Cur)
		if not _Cur then return _String end
		local long=_Cur
		for i=math.min(#_String,#_Cur),_Min,-1 do
			local a,b=string.sub (_String,1,i),string.sub(_Cur,1,i)
			if a==b then return a end		
		end	
		return string.sub (_Cur,1,_Min)
	end
	
	local tick
	if bClock then tick=os.startTimer(1) end
	redraw()
	while true do
		local sEvent, param = os.pullEvent()
		if sEvent =="timer" and param==tick then shellclock() tick=os.startTimer(1)
		elseif sEvent == "char" then
			sLine = string.sub( sLine, 1, nPos ) .. param .. string.sub( sLine, nPos + 1 )
			nPos = nPos + 1
			redraw()
			
		elseif sEvent == "key" then
		    if param == keys.enter then
				--[[ Enter --]]
				shellclock(true)
				break
				
			elseif param == keys.left then
				--[[ Left --]]
				if nPos > 0 then
					redraw(" ")
					nPos = nPos - 1
					redraw()
				end
				
			elseif param == keys.right then
				--[[ Right --]]				
				if nPos < string.len(sLine) then
					redraw(" ")
					nPos = nPos + 1
					redraw()
				end
			
			elseif param == keys.up or param == keys.down then
                --[[ Up or down --]]
				if _tHistory then
					redraw(" ")
					if param == keys.up then
						--[[ Up --]]
						if nHistoryPos == nil then
							if #_tHistory > 0 then
								nHistoryPos = #_tHistory
							end
						elseif nHistoryPos > 1 then
							nHistoryPos = nHistoryPos - 1
						end
					else
						--[[ Down --]]
						if nHistoryPos == #_tHistory then
							nHistoryPos = nil
						elseif nHistoryPos ~= nil then
							nHistoryPos = nHistoryPos + 1
						end						
					end
					if nHistoryPos then
                    	sLine = _tHistory[nHistoryPos]
                    	nPos = string.len( sLine ) 
                    else
						sLine = ""
						nPos = 0
					end
					redraw()
                end
			elseif param == keys.backspace then
				--[[ Backspace --]]
				if nPos > 0 then
					redraw(" ")
					sLine = string.sub( sLine, 1, nPos - 1 ) .. string.sub( sLine, nPos + 1 )
					nPos = nPos - 1					
					redraw()
				end
			elseif param == keys.home then
				--[[ Home --]]
				redraw(" ")
				nPos = 0
				redraw()		
			elseif param == keys.delete then
				if nPos < string.len(sLine) then
					redraw(" ")
					sLine = string.sub( sLine, 1, nPos ) .. string.sub( sLine, nPos + 2 )				
					redraw()
				end
			elseif param == keys["end"] then
				--[[ End --]]
				redraw(" ")
				nPos = string.len(sLine)
				redraw()
			elseif param == keys.tab and (string.sub( sLine, nPos+1 ,nPos+1)==" " or nPos==string.len(sLine)) then
				--[[ Tab  --]]
				local need=string.match(string.sub(sLine,1,nPos),"[ ]?([^ ]-)$")
				if need=="" or string.match(need,"[\\/]$") then

					--[[looking at root or /,\ at end mean folder --]]
					local path=shell.resolve(need or "")
					if fs.exists(path) and fs.isDir(path) then list(fs.list(path),path,true) end
					
				else
					--[[have part of name --]]					
					--[[get absolute path and target name --]]
					local path=""
					local targ=""
					if need=="." or string.match(need,"[\\/]%.$") then --[[lokking for hidden in folder --]]
						path=shell.resolve(need).."/"
						targ="."
					else --[[lokking for normal file --]]
						path=shell.resolve(need)
						targ=fs.getName(path)
					end
					
					--[[get path without name and see it iteven exists --]]
					path=string.sub(path,1,#path-#targ) or ""
					if fs.exists(path) and fs.isDir(path) then
						
						--[[find files in path matching part --]]
						--[[at same time look for longest common leading substing --]]
						local out={}
						local long=nil
						local lim=#targ
						 --[[Sanitizing magic for pattern needs ^$()%.[]*+-?--]]
						local pattern="^"..string.gsub(string.lower(targ),"[%^%$%(%)%%%.%[%]%*%+%-%?]",function(A) return "%"..A end)
						for i,k in pairs(fs.list(path)) do
							local tempS=string.lower(k)
							if string.match(tempS,pattern) then
								table.insert(out,k)
								long=common(tempS,lim,long)
							end
						end
						if #out==1 then
							if fs.isDir(fs.combine(path,out[1])) then out[1]=out[1].."/" end
							sLine=string.sub(sLine,1,nPos-#targ)..out[1]..string.sub( sLine, nPos + 1 )
							nPos = nPos-#targ+#out[1]
						elseif #out>1 then
							sLine=string.sub( sLine, 1, nPos-#targ )..long..string.sub( sLine, nPos + 1 )
							nPos = nPos-#targ+#long
							list(out,path)							
						end	
					end
				end
				redraw()
			end
		end
	end
	
	term.setCursorBlink( false )
	term.setCursorPos( w + 1, sy )
	print()
	
	return sLine
end

--[[ Back to standard shell with extended modyfications  --]]
	
term.setBackgroundColor( bgColour )
term.setTextColour( promptColour )
print( os.version(), " Extended v 2.0" )
term.setTextColour( textColour )

--[[ If this is the toplevel shell, run the startup programs  --]]
if parentShell == nil then
	--[[ Run the startup from the ROM first  --]]
	local sRomStartup = shell.resolveProgram( "/rom/startup" )
	if sRomStartup then
		shell.run( sRomStartup )
	end
	
	--[[ Then run the user created startup, from the disks or the root  --]]
	local sUserStartup = shell.resolveProgram( "/startup" )
	for n,sSide in pairs( peripheral.getNames() ) do
		if disk.isPresent( sSide ) and disk.hasData( sSide ) then
			local sDiskStartup = shell.resolveProgram( fs.combine(disk.getMountPath( sSide ), "startup") )
			if sDiskStartup then
				sUserStartup = sDiskStartup
				break
			end
		end
	end
	
	if sUserStartup then
		shell.run( sUserStartup )
	end
end

--[[ Run any programs passed in as arguments  --]]
local tArgs = { ... }
if #tArgs > 0 then
	shell.run( ... )
end

--[[ Read commands and execute them -- Most of modyfications happend here  --]]
local tCommandHistoryfile=fs.combine(saveDir,".shellhistory.log")
local tCommandHistory = {}
if fs.exists(tCommandHistoryfile) then tCommandHistory = getT(tCommandHistoryfile) or {} end
local nextprefix = ""
while not bExit do
	term.setBackgroundColor( bgColour )
	term.setTextColour( promptColour )
	write( shell.dir() .. "> " )
	term.setTextColour( textColour )
	
	local sLine = readtab( nil, tCommandHistory ,nextprefix)
	nextprefix = ""
	if sLine~="" then
	
		if sLine ~= tCommandHistory[#tCommandHistory] then
			table.insert( tCommandHistory, sLine )
			if tCommandHistory[101] then table.remove(tCommandHistory,1) end
			saveT(tCommandHistoryfile,tCommandHistory)
		end
		
		local tWords = {}
			for match in string.gmatch( sLine, "[^ \t]+" ) do
			table.insert( tWords, match )
		end
		local sCommand = table.remove(tWords,1)
		
		if sCommand == "lua<" then --[[ Lua Execution --]]
			runlua( string.sub( sLine, 6) )
			nextprefix = "lua< "
		elseif sCommand == "lua#" then --[[ Lua Clear --]]
			LuatEnv = {} setmetatable( LuatEnv, { __index = getfenv() } ) print("Shell Lua Enviroment Cleared")
		elseif sCommand == "cat<" then	--[[ Cat Execution --]]
			cat(tWords)	
		elseif sCommand == "clock<" then	--[[ Clock Toggle --]]
			bClock=not bClock print("Clock ",(bClock and "On")or"Off")
		elseif sCommand == "find<" then	--[[ Find Execution --]]
			findfile(string.sub( sLine, 7))
		elseif sCommand == "findpattern<" then	--[[ Find with pattern Execution --]]
			findfile(string.sub( sLine, 14),true)
		elseif sCommand == "plogin<" then	--[[ pastebin login --]]
			pastelogin()
		elseif sCommand == "plogout<" then	--[[ pastebin plogout --]]
			pastelogout()
		elseif sCommand == "pget<" then	--[[ Find with pattern Execution --]]
			local tar=string.sub( sLine, 7)
			pasteget(tar)
		elseif sCommand == "plist<" then	--[[ Find with pattern Execution --]]
			pasteget()
		elseif sCommand == "help<" or sCommand == "?<"  then	--[[ Help Execution --]]
			print("List of extra shell commands: lua<,lua#,cat<,clock<,find<,findpattern<,help<",(http and ",plogin<,plogout<,pget<,plist<" or ""))
		elseif sCommand then --[[ Standard Execution --]]
			run( sCommand, unpack( tWords ) )
		end
	end	
end

--[[ If this is the toplevel shell, run the shutdown program  --]]
if parentShell == nil then
	if shell.resolveProgram( "shutdown" ) then
		shell.run( "shutdown" )
	end
	os.shutdown() --[[ just in case  --]]
end

term.setTextColour( promptColour )
print("Extended Shell Terminated.")
print("Have a Nice Day!")
term.setTextColour( textColour )
