블로그는 귀차니즘

  음 재미가 있는 관계로 코딩을 계속하다보니 어느새 프로토타입에서 벗어나 어느정도 구조를 갖추고 되었습니다. 리다이렉션을 비롯해서 Dir, Exit 등의 기능도 들어가게 되었습니다. 아직 미완성 적인 부분도 많이 존재하고 수정중인 버그도 존재합니다. 하지만 이런 진행과정을 남기고 싶어서 포스팅하게 되었습니다. 어느정도 되는 프로그램이 갑자기 어디서 뚝 떨어질리는 없지 않겠습니까?^^

shell.cpp (Language : cpp)

1. #ifdef HAVE_CONFIG_H
2. #include <config.h>
3. #endif
5. #include "tshell.h"
7. int main( int argc, char **argv)
8. {
9.     TShell ShellObject;
11.     ShellObject.Run();
13.     return 0;
14. }

  예전엔 Main코드 상에서 바로 측정을 진행하였지만 객체화를 안시켜놓으니 new를 통한 객체할당에 대한 해제가 이루어지지 않는 문제점이 존재한다고 생각하여 클래스화 하였습니다. 지금 생각중인 것은 TShell을 Singleton 인터페이스화 하여 alias 같은 명령어가 작동할 수 있도록 하는 것입니다.
  나중에 한 번 수정을 해봐야 겠네요..

tshell.h (Language : cpp)

1. #pragma once
3. #include <iostream>
4. #include <iomanip>
5. #include <string>
6. #include <vector>
7. #include <stack>
8. #include <map>
10. #include <termios.h>
12. #include "cshellcommand.h"
14. #include "cactionobject.h"
15. #include "cfileobject.h"
16. #include "cexitobject.h"
17. #include "cdirobject.h"
18. #include "cshobject.h"
19. #include "ccdobject.h"
21. typedef std::map< std::string, CActionObject * > CommandVector;
23. class TShell : private CShellCommand
24. {
25. public:
26.     TShell(void);
27.     ~TShell(void);
29.     void Run();
31. private:
32.     void InitializeCommandMap();
33.     void TerminalizeCommandMap();
35.     void DoInputWork(std::string &InputBuffer);
38.     void PrintShellString(const std::string &CommandBuffer);
39.     bool PrintNearestCommand( const std::string &Token );
41.     void StringTokenizer( const std::string &Str, std::vector< std::string > &Token, const std::string &Delimiter );
43.     char getch(void);
45.     CommandVector CommandTable;
46. };

tshell.cpp (Language : cpp)

1. #include "tshell.h"
3. TShell::TShell(void)
4. {
5.     InitializeCommandMap();
6. }
8. TShell::~TShell(void)
9. {
10.     TerminalizeCommandMap();
11. }
13. void TShell::InitializeCommandMap()
14. {
15.     try {
17.         CommandTable.insert( std::make_pair( "exit", new CExitObject ) );
18.         CommandTable.insert( std::make_pair( "dir", new CDirObject ) );
19.         CommandTable.insert( std::make_pair( "sh", new CShObject ) );
20.         CommandTable.insert( std::make_pair( "cd", new CCdObject ) );
21.     }
22.     catch( ... )    {
23.     }
24. }
26. void TShell::TerminalizeCommandMap()
27. {
28.     for( CommandVector::const_iterator Iter = CommandTable.begin(); Iter != CommandTable.end(); ++Iter )    {
29.         try {
31.             delete Iter->second;
32.         }
33.         catch( ... )    {
34.         }
35.     }
36. }
38. void TShell::Run()
39. {
40.     std::string InputBuffer;
42.     while( true )    {
44.         InputBuffer.clear();
45.         DoInputWork( InputBuffer );
47.         std::vector< std::string > PipeVector;
48.         StringTokenizer( InputBuffer, PipeVector, "|" );
49.         for( std::vector< std::string >::const_iterator Iter = PipeVector.begin(); Iter != PipeVector.end(); ++Iter )   {
51.             std::vector< std::string > ArgumentTable;
52.             StringTokenizer( *Iter, ArgumentTable, " \t\r\n" );
54.             if( ArgumentTable.size() != 0 ) {
56.                 CommandVector::const_iterator Accessor = CommandTable.find( ArgumentTable[ 0 ] );
57.                 if( Accessor != CommandTable.end() )    {
59.                     if( !Accessor->second->DoAction( ArgumentTable ) )
60.                         return;
61.                 }
62.                 else    {
64.                     CFileObject CFObject;
65.                     CFObject.DoAction( ArgumentTable );
66.                 }
67.             }
68.         }
69.     }
70. }
72. void TShell::DoInputWork(std::string &InputBuffer )
73. {
74.     std::stack< std::string > TokenStack;
75.     std::string CurrentToken;
77.     PrintShellString( "" );
79.     int InputChar;
80.     while( ( InputChar = getch() ) != '\n' )    {
82.         switch( InputChar ) {
84.             case '\t':
85.                 if( TokenStack.empty() || TokenStack.top() == "|" ) {
86.                     if( PrintNearestCommand(CurrentToken) )
87.                         PrintShellString(InputBuffer);
88.                 }
89.                 break;
90.             case 127://'\b'
91.                 {
92.                     std::string::size_type SizeIndex = InputBuffer.length();
93.                     if( SizeIndex-- > 0 )   {
95.                         if( InputBuffer[ SizeIndex ] == ' ' )   {
96.                             CurrentToken = TokenStack.top();
97.                             TokenStack.pop();
98.                         }
99.                         else    {
100.                             CurrentToken.erase( CurrentToken.length() - 1, 1 );
101.                         }
102.                         InputBuffer.erase( SizeIndex, 1 );
103.                         std::cout << "\b \b";
104.                     }
105.                 }
106.                 break;
107.             case ' ':
108.                 InputBuffer += InputChar;
109.                 TokenStack.push(CurrentToken);
110.                 CurrentToken.clear();
111.                 std::cout.put(InputChar);
112.                 break;
113.             default:
114.                 InputBuffer += InputChar;
115.                 CurrentToken += InputChar;
116.                 std::cout.put(InputChar);
117.                 break;
118.         }
119.     }
121.     std::cout << std::endl;
122. }
124. void TShell::PrintShellString(const std::string &CommandBuffer)
125. {
126.     std::cout << "[" + GetCurrentWorkingDirectory() + "]$" << CommandBuffer;
127. }
129. bool TShell::PrintNearestCommand( const std::string &Token )
130. {
131.     bool IsPrinted = false;
132.     unsigned int Count = 0, TokenLength = Token.length();
134.     for( CommandVector::const_iterator Iter = CommandTable.begin(); Iter != CommandTable.end(); ++Iter )    {
136.         const std::string &KeyString = Iter->first;
137.         if( KeyString.length() >= TokenLength ) {
139.             if( KeyString.substr( 0, TokenLength ) == Token )   {
141.                 if( Count % 5 == 0 )
142.                     std::cout << std::endl;
144.                 std::cout << "[" << KeyString << "]" << std::setw(6) << "\t";
145.                 Count++;
146.                 IsPrinted = true;
147.             }
148.         }
149.     }
151.     if( IsPrinted )
152.         std::cout << std::endl;
154.     return IsPrinted;
155. }
157. char TShell::getch(void)
158. {
159.     struct termios oldt, newt;
160.     int ch;
161.     tcgetattr(STDIN_FILENO, &oldt);
162.     newt = oldt;
163.     newt.c_lflag &= ~(ICANON | ECHO);
164.     tcsetattr(STDIN_FILENO, TCSANOW, &newt);
165.     ch = getchar();
166.     tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
167.     return ch;
168. }
170. void TShell::StringTokenizer( const std::string &Str, std::vector< std::string > &Token, const std::string &Delimiter )
171. {
172.     std::string::size_type LastPos = Str.find_first_not_of( Delimiter, 0 );
173.     std::string::size_type Pos     = Str.find_first_of( Delimiter, LastPos );
175.     while( std::string::npos != Pos || std::string::npos != LastPos )
176.     {
177.         Token.push_back( Str.substr( LastPos, Pos - LastPos ) );
178.         LastPos = Str.find_first_not_of( Delimiter, Pos );
179.         Pos = Str.find_first_of( Delimiter, LastPos );
180.     }
181. }

  음 여기서 다른 부분은 예전 버젼과 동일하지만 getch 함수가 C 표준함수가 아니다보니 실질적으로 프로그램에 문제가 있었고 그로인해 glibc환경에서 동작하는 getch소스를 가져와서 구현하게 되었습니다. getch는 아마도 CShellCommand 클래스로 자리를 이동해야 할 것 같군요. 어차피 private 상속이니까요.
  그리고 키 입력을 통한 처리를 DoInputWork라는 함수 안에서 getch를 통하여 구현을 하게 되었는데, 아직 화살표키 등의 처리를 진행하지 않았기 때문에 그에 따른 처리가 추가적으로 등록되어야 할 것같습니다.

CActionObject.h (Language : cpp)

1. #pragma once
3. #include <string>
4. #include <vector>
5. #include <fcntl.h>
7. class CActionObject
8. {
9. public:
10.     CActionObject(void);
11.     virtual ~CActionObject(void);
13.     virtual bool DoAction( std::vector< std::string > &Argument ) = 0;
15.     void SetRedirection( std::vector< std::string > &Argument );
16.     void ResetRedirection();
18. private:
19.     int STDOUTFileDesc, STDINFileDesc;
20.     int OldSTDOUT, OldSTDIN;
21.     bool STDOUTRedirection, STDINRedirection;
23.     static const int STDOUT = 1;
24.     static const int STDIN = 0;
25. };

CActionObject.cpp (Language : cpp)

1. #include "cactionobject.h"
3. CActionObject::CActionObject()
4.     :   STDINRedirection( false ), STDOUTRedirection( false )
5. {
6. }
9. CActionObject::~CActionObject()
10. {
11. }
13. void CActionObject::SetRedirection( std::vector< std::string > &Argument )
14. {
15.     std::vector< std::string >::const_iterator End = Argument.end();
16.     for( std::vector< std::string >::const_iterator Iter = Argument.begin();
17.         Iter != Argument.end(); ++Iter )    {
19.         if( *Iter == ">" && ++Iter != End ) {
21.             STDOUTRedirection = true;
22.             STDOUTFileDesc = open( Iter->c_str(), O_CREAT | O_RDWR | S_IREAD | S_IWRITE );
23.             OldSTDOUT = dup( STDOUT );
24.             dup2( STDOUTFileDesc, STDOUT );  
25.         }
26.         else if( *Iter == "<" && ++Iter != End )    {
28.             STDINRedirection = true;
29.             STDINFileDesc = open( Iter->c_str(), O_RDONLY );
30.             OldSTDIN = dup( STDIN );
31.             dup2( STDINFileDesc, STDIN );
32.         }
33.     }
34. }
36. void CActionObject::ResetRedirection()
37. {
38.     if( STDOUTRedirection ) {
39.         close( STDOUTFileDesc );
40.         dup2( OldSTDOUT, STDOUT );
41.         close( OldSTDOUT );
42.         STDOUTRedirection = false;
43.     }
45.     if( STDINRedirection )  {
46.         close( STDINFileDesc );
47.         dup2( OldSTDIN, STDIN );
48.         close( OldSTDIN );
49.         STDINRedirection = false;
50.     }
51. }

  SetRedirection 과 ResetRedirection 함수를 통하여 만약 > 파일명, < 파일명이 있다면 리다이렉션 기능이 수행 되게 하였습니다. dup함수와 dup2함수를 통하여 제작을 하였습니다. 실질적으로 CActionObject 클래스가 하는 역할은 거의 없다고 봐도 무방하죠^^;

CCdObject.h (Language : cpp)

1. #pragma once
3. #include <iostream>
4. #include <vector>
5. #include <string>
7. #include "cactionobject.h"
8. #include "cshellcommand.h"
10. class CCdObject
11.     : public CActionObject, private CShellCommand   {
12. public:
13.     CCdObject();
14.     ~CCdObject();
16.     bool DoAction( std::vector< std::string > &Argument );
17. };

CCdObject.cpp (Language : cpp)

1. #include "ccdobject.h"
3. CCdObject::CCdObject()
4. {
5. }
8. CCdObject::~CCdObject()
9. {
10. }
12. bool CCdObject::DoAction( std::vector< std::string > &Argument )
13. {
14.     SetRedirection( Argument );
16.     std::vector< std::string >::size_type ArgumentSize = Argument.size();
17.     if( ArgumentSize == 1 ) {
19.         std::cout << GetCurrentWorkingDirectory() << std::endl;
20.     }
21.     else if( ArgumentSize == 2 )    {
23.         chdir( Argument[ 1 ].c_str() );
24.     }
26.     ResetRedirection();
27.     return true;
28. }

  cd 를 통한 디렉토리 이동 기능을 구현해놓은 클래스입니다. CShellCommand 클래스를 private 상속 받은 것은 아시다시피 GetCurrentWorkingDirectory 함수를 사용하기 위해서 입니다. 보시면 cd .. 을 하지 않고 cd . 했을때 현재의 프로젝트를 출력하기만 하기에 이렇게 구현할 수 밖에 없었죠.
  디렉토리 들어가지 못했을 때의 경우를 chdir 리턴값을 체크하여 에러메시지 출력을 따로 해야겠습니다.

CExitObject.h (Language : cpp)

1. #pragma once
3. #include <iostream>
5. #include "cactionobject.h"
7. class CExitObject
8.     : public CActionObject
9. {
10. public:
11.     CExitObject(void);
12.     ~CExitObject(void);
14.     bool DoAction( std::vector< std::string > &Argument );
15. };

CExitObject.cpp (Language : cpp)

1. #include "cexitobject.h"
3. CExitObject::CExitObject(void)
4. {
5. }
7. CExitObject::~CExitObject(void)
8. {
9. }
11. bool CExitObject::DoAction( std::vector< std::string > &Argument )
12. {
13.     return false;
14. }

  exit 명령을 통하여 쉘을 종료하기 위하여 제작한 클래스인데, 실질적으로 tshell.cpp 구현부에서 해당 DoAction함수의 실행 리턴값을 체크하여 프로그램을 종료할 것인가 결정하는 부분이 존재하다보니 그냥 false를 리턴하는 코드만 넣게 되었습니다.

CDirObject.h (Language : cpp)

1. #pragma once
3. #include <iostream>
4. #include <sstream>
5. #include <vector>
6. #include <iterator>
7. #include <algorithm>
8. #include <iomanip.h>
9. #include <time.h>
10. #include <dirent.h>
11. #include <sys/stat.h>
13. #include "cshellcommand.h"
15. #include "cactionobject.h"
17. namespace Option    {
19.     enum OptionMode {
20.         Simple,
21.         Page,
22.         Wide,
23.         Recursive
24.     };
25. }
27. struct FileInformation  {
28.     std::string Time;
29.     bool IsDirectory;
30.     std::string Name;
31.     long long Size;
32. };
34. class CDirObject
35.     : public CActionObject, private CShellCommand
36. {
37. public:
38.     CDirObject(void);
39.     ~CDirObject(void);
41.     bool DoAction( std::vector< std::string > &Argument );
42. };
44. struct SimplePrint  {
46.     SimplePrint( bool IsPagePrint )
47.         : IsPage( IsPagePrint ), RowNumber( 0 ) {
49.     }
51.     void operator()( FileInformation &FileInfo )    {
53.         std::cout << FileInfo.Time;
55.         if( FileInfo.IsDirectory )  {
57.             std::cout << "<DIR>        ";
58.         }
59.         else    {
60.             std::cout << setw( 12 ) << setfill(' ') << FileInfo.Size << " ";
61.         }
63.         std::cout << setw( 30 ) << ( FileInfo.Name.length() > 30 ? FileInfo.Name.substr( 0, 28 ) + ".." : FileInfo.Name )
64.             << std::endl;
66.         if( IsPage )    {
68.             if( ( ++RowNumber % 10 ) == 0 ) {
69.                 std::cout << "계속하려면 엔터키를 누르십시오.";
70.                 std::cin.get();
71.             }
72.         }
73.     }
75. private:
76.     bool IsPage;
77.     int RowNumber;
78. };
80. struct WidePrint    {
82.     WidePrint()
83.         : ColNumber( 0 )    {
84.     }
86.     void operator()( FileInformation &FileInfo )    {
88.         std::cout << "[" << setw( 10 ) << ( FileInfo.Name.length() > 10 ? FileInfo.Name.substr( 0, 8 ) + ".." : FileInfo.Name )
89.             << "]";
91.         if( ( ++ColNumber % 5 ) == 0 )
92.             std::cout << std::endl;
93.         else
94.             std::cout << "\t";
95.     }
97. private:
98.     int ColNumber;
99. };
101. struct RecursivePrint   {
103.     RecursivePrint( std::string &CurrentDirectory, std::vector< std::string > &Argument )
104.         : DummyCurrentDirectory( CurrentDirectory ), DummyArgument( Argument )  {
105.     }
107.     void operator()( std::string &DirectoryName )   {
109.         std::string CurrentDirectory( DummyCurrentDirectory );
110.         CurrentDirectory += "/";
111.         CurrentDirectory += DirectoryName;
113.         DummyArgument.push_back( CurrentDirectory );
114.         TempObject.DoAction( DummyArgument );
115.         DummyArgument.erase( --DummyArgument.end() );
116.     }
118. private:
119.     std::string &DummyCurrentDirectory;
120.     std::vector< std::string > &DummyArgument;
122.     CDirObject TempObject;
123. };

CDirObject.cpp (Language : cpp)

1. #include "cdirobject.h"
3. CDirObject::CDirObject(void)
4. {
5. }
7. CDirObject::~CDirObject(void)
8. {
9. }
11. bool CDirObject::DoAction( std::vector< std::string > &Argument )
12. {
13.     SetRedirection( Argument );
15.     std::string &Command = Argument[ 0 ];
16.     Option::OptionMode ArgumentOptionMode = Option::Simple;
18.     std::vector< std::string > DirectoryTable;
19.     std::vector< std::string > OptionTable;
21.     for( std::vector< std::string >::const_iterator Iter = ++Argument.begin();
22.         Iter != Argument.end();
23.         ++Iter )
24.     {
25.         if( *Iter == "/?" ) {
26.             std::cout << "Command : " << Command << "( 디렉토리 나열 명령어 ) 사용 예는 아래와 같습니다." << std::endl
27.                 << "ex ) " << Command << "      - 조건없이 단순히 나열합니다." << std::endl
28.                 << "     " << Command << " /w         - 파일명을 Wide형태로 나열합니다." << std::endl
29.                 << "     " << Command << " /p         - 페이지 형태로 나열합니다." << std::endl
30.                 << "     " << Command << " /s         - 하위 디렉토리를 포함하여 나열합니다." << std::endl
31.                 << "     " << Command << " [디렉토리명 ... ]   - 해당 디렉토리의 내용을 나열합니다." << std::endl
32.                 << "     " << Command << " - 옵션은 마지막 옵션만 사용됩니다. 다른 옵션은 무시됩니다." << std::endl;
33.             return true;
34.         }
35.         else if( *Iter == "/w" )    {
36.             ArgumentOptionMode = Option::Wide;
37.         }
38.         else if( *Iter == "/p" )    {
39.             ArgumentOptionMode = Option::Page;
40.         }
41.         else if( *Iter == "/s" )    {
42.             ArgumentOptionMode = Option::Recursive;
43.         }
44.         else    {
45.             DirectoryTable.push_back( *Iter );
46.             continue;
47.         }
49.         OptionTable.push_back( *Iter );
50.     }
52.     std::string::size_type DirectoryNumber = DirectoryTable.size();
53.     std::string CWDirectory;
54.     if( DirectoryNumber == 0 )  {
55.          CWDirectory = GetCurrentWorkingDirectory();
56.     }
57.     if( DirectoryNumber == 1 )  {
58.         CWDirectory = GetCurrentWorkingDirectory();
59.         CWDirectory += "/";
60.         CWDirectory += DirectoryTable.front();
61.         DirectoryTable.clear();
62.     }
63.     else if( DirectoryNumber > 1 )  {
65.         std::vector< std::string > TempVector;
67.         TempVector.push_back(Argument.front());
68.         std::copy( OptionTable.begin(), OptionTable.end(), std::back_insert_iterator< std::vector< std::string > >( TempVector ) );
69.         std::for_each( DirectoryTable.begin(), DirectoryTable.end(), RecursivePrint( CWDirectory, TempVector ) );
70.         return true;
71.     }
73.     long long int m_TotalFileSize = 0;
74.     int m_TotalFileNum = 0;
75.     int m_TotalDirectoryNum = 0;
77.     std::vector< FileInformation > StatList;
79.     std::string m_DirectoryParent( "." );
80.     std::string m_DirectoryCurrent( ".." );
82.     struct tm *GmTime;
83.     struct stat Fstat;
84.     struct dirent **items;
86.     int filenum = scandir( CWDirectory.c_str(), &items, NULL, alphasort);
88.     std::cout << std::endl << "  현재 디렉토리 : " << CWDirectory << std::endl << std::endl;
90.     for ( int i = 0; i < filenum; i++)    {
92.         FileInformation FileInfo;
94.         lstat( items[i]->d_name, &Fstat);
95.         GmTime = gmtime( static_cast< const time_t* >( &Fstat.st_atime ) );
97.         std::ostringstream StringFormatter;
98.         StringFormatter << 1900 + GmTime->tm_year << "-" << setw(2) << setfill('0')
99.             << GmTime->tm_mon << "-" << setw(2)
100.             << GmTime->tm_mday << "  "
101.             << ( GmTime->tm_hour > 12 ? "오후" : "오전" ) << " "
102.             << setw(2) << (GmTime->tm_hour%12) << ":"
103.             << setw(2) << (GmTime->tm_min) << ":"
104.             << setw(2) << (GmTime->tm_sec) << "   ";
106.         FileInfo.Time = StringFormatter.str();
108.         FileInfo.Name = items[i]->d_name;
110.         if( !S_ISREG(Fstat.st_mode) )   {
112.             if( m_DirectoryParent != items[i]->d_name && m_DirectoryCurrent != items[i]->d_name )   {
113.                 DirectoryTable.push_back( items[i]->d_name );
114.             }
116.             FileInfo.IsDirectory = true;
117.             FileInfo.Size = 0;
119.             m_TotalDirectoryNum++;
120.         }
121.         else    {
123.             FileInfo.IsDirectory = false;
124.             FileInfo.Size = Fstat.st_size;
126.             m_TotalFileNum++;
127.             m_TotalFileSize += Fstat.st_size;
128.         }
130.         StatList.push_back( FileInfo );
131.     }
133.     switch( ArgumentOptionMode )    {
135.         case Option::Simple:
136.             std::for_each( StatList.begin(), StatList.end(), SimplePrint( false ) );
137.             break;
138.         case Option::Wide:
139.             std::for_each( StatList.begin(), StatList.end(), WidePrint() );
140.             break;
141.         case Option::Page:
142.             std::for_each( StatList.begin(), StatList.end(), SimplePrint( true ) );
143.             break;
144.         case Option::Recursive:
145.             std::vector< std::string > TempVector;
147.             TempVector.push_back(Argument.front());
148.             std::copy( OptionTable.begin(), OptionTable.end(), std::back_insert_iterator< std::vector< std::string > >( TempVector ) );
150.             std::for_each( StatList.begin(), StatList.end(), SimplePrint( false ) );
151.             std::for_each( DirectoryTable.begin(), DirectoryTable.end(), RecursivePrint( CWDirectory, TempVector ) );
152.             break;
153.     }
155.     std::cout << std::endl << setfill(' ')
156.         << setw( 30 ) << m_TotalDirectoryNum << "개 디렉토리" << std::endl
157.         << setw( 30 ) << m_TotalFileNum << "개 파일"
158.         << setw( 30 ) << m_TotalFileSize << " 바이트" << std::endl << std::endl;
160.     ResetRedirection();
162.     return true;
163. }

  주력 기능으로 제작하기 위하여 많은 코딩량이 들어간 CDirObject 입니다. 기능은 /w /p /s 디렉토리 나열 등이 있는데, 현재 /s 버젼 및, 디렉토리 나열 기능에 대하여는 버그가 존재합니다. S_ISDIR 부분이 왠일인지 이상하게 파일인데도 불구하고 DIR로 인식하는지 true가 리턴되더군요. 만약 해결 된다면 문제가 어느정도 괜찮을 것 같습니다.
  디렉토리 내용의 출력은 함수 객체를 사용하였는데, CDirObject.h 파일에 존재하는 ???Print 구조체의 ()연산자를 오버로딩하여 출력을 구성했습니다. 역시 편리한 점이 없지않아 있더군요. 출력 형식은 윈도우즈 cmd.exe 에서 dir 했을 때와 비슷하게 구현했습니다.

CShellCommand.h (Language : cpp)

1. #pragma once
3. #include <string>
5. class CShellCommand{
6. public:
7.     CShellCommand();
8.     ~CShellCommand();
10.     std::string GetCurrentWorkingDirectory();
11. };

CShellCommand.cpp (Language : cpp)

1. #include "cshellcommand.h"
3. CShellCommand::CShellCommand()
4. {
5. }
8. CShellCommand::~CShellCommand()
9. {
10. }
12. std::string CShellCommand::GetCurrentWorkingDirectory()
13. {
14.     const int BufferSize = 500;
15.     char CurrentWorkingDirectoryBuffer[ BufferSize ] = { 0,};
16.     return getcwd( CurrentWorkingDirectoryBuffer, BufferSize - 1 );
17. }

  private 상속을 위한 Shell과 관련된 기능 구현 CShellCommand 클래스이다 보니 마지막으로 밀리게 되었군요. 지금 현재는 GetCurrentWorkingDirectory 함수만 존재하지만 getch 함수도 이동하고 그러면 어느정도 채워 지겠군요. 또한 기능이 복잡해지고 한다면 여러모로 많이 복잡할 것 같이 보입니다^^;

  이 외에도 쉘 스크립트 기능, 파일 실행 기능들도 넣으려고 하는데 아직 작업을 진행하지 못하였군요. 버그를 수정하여 완벽한 쉘이 될 수 있도록 개정해봐야 겠습니다.^^; 다른 것도 아니고 스스로 사용할 것인데요. 그럼 오늘도 즐거운 하루 되시길.

=뱀다리=
그나저나 이번에도 올려놓고 보니 + 연산으로 임시객체를 남발하는 코드가 몇 군데 있고 효율을 떨어트리는 코드가 존재하는군요. 다음버젼엔 수정하여 올려야 겠습니다.

크리에이티브 커먼즈 라이센스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.