Script Programming(스크립트 프로그래밍)

소스 파일명: testIf.py

1. {-#
2.    Filename: testIf.hs
3.    Purpose:  Example using the conditional control structure syntax
4.                  if .... else ... then ...
5.    Execute: runhugs testIf.hs [number]
6.          Or
7.             runhaskell testIf.hs [number]
8. #-}
10. module Main where
11. import System.Environment
13. -- 사용법을 보여주는 함수
14. printUsing :: IO ()
15. printUsing = do
16.     putStrLn "Using: runhugs testIf.hs [number]"
17.     putStrLn "This determines whether the number is positive or not."
19. main :: IO ()
20. main = do
21.     args <- getArgs
22.     -- 명령행 인자의 개수가 1이 아니면 사용법을 보여준다.
23.     if not ((length args) == 1)
24.         then printUsing
25.         else do
26.             let val = toDouble (args !! 0)
27.             if val > 0.0
28.                then putStrLn ((show val) ++ " is a positive number.")
29.                else if val < 0.0
30.                    then putStrLn ((show val) ++ " is a negative number.")
31.                    else putStrLn ((show val) ++ " is zero.")
33. toDouble :: [Char] -> Double
34. toDouble x = (read x) :: Double

위의 소스에서
            if not ((length args) == 1)
로 된 부부은
            if not ((length args) == 1)
로 해도 된다. 즉, Haskell 언어의 /=  비교연산자는 C 언어의 != 비교연산자와 같은 의미이다.

실행> runhugs testIf.hs
Using: runhugs testIf.hs [number]
This determines whether the number is positive or not.

실행> runhugs testIf.hs 6.25
6.25 is a positive number.

실행> runhugs testIf.hs -6.25
-6.25 is a negative number.



* GHC의 ghc 명령으로 컴파일한 후 실행하기

컴파일> ghc --make testIf.hs

testIf.hs:1:0: Unrecognised pragma
[1 of 1] Compiling Main             ( testIf.hs, testIf.o )

testIf.hs:1:0: Unrecognised pragma
Linking testIf.exe ...

실행> testIf
Using: runhugs testIf.hs [number]
This determines whether the number is positive or not.

실행> testIf 6.25
6.25 is a positive number.

실행> testIf -6.25
-6.25 is a negative number.





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

* WInHugs에서 runhugs로 실행하기
프롬프트> runhugs sumSquares.hs 1 2 3 4 5
[1.0,4.0,9.0,16.0,25.0]
Total is 55.0

프롬프트> runhugs sumSquares2.hs 1 2 3 4 5
[1.0,4.0,9.0,16.0,25.0]
Total is 55.0



* GHC의 runhaskell로 실행하기
프롬프트> runhaskell sumSquares2.hs 1 2 3 4 5
[1.0,4.0,9.0,16.0,25.0]
Total is 55.0

프롬프트> runhaskell sumSquares.hs 1 2 3 4 5
[1.0,4.0,9.0,16.0,25.0]
Total is 55.0



* GHC의 ghcl로 컴파일한 후 실행하기 (--make 옵션은 실행파일을 만들라는 의미의 옵션이다.)
프롬프트> ghc --make sumSquares.hs

프롬프트>sumSquares
[]
Total is 0.0

프롬프트> sumSquares 1 2 3 4 5
[1.0,4.0,9.0,16.0,25.0]
Total is 55.0

Haskell 언어에서 지수 계산하는 연산자는 ^와 ** 두 가지가 있다.
그런데 ^는 긴 계산 결과가 긴 정수이고, **는 게산 결과가 부동소수점수이다.

* GHC의 ghci를 이용하여 지수 계산을 테스트해 보았다.
  :set prompt "스트링"은 GHC에서 지원하는 프롬프트 변경 명령이다.

* WinHugs의 hugs를 이용하여 지수 계산을 테스트해 보았다.
  :set -p"스트링"은 WunHugs에서 지원하는 프롬프트 변경 명령이다.

Haskell 언어로 구구단 중의 2단을 출력하는 프로그램 소스를 작성해 보았다.
Haskell 언어는 순수한 함수형 언어이기 때문에 절차적 언어에서 많이 쓰는 for 반복문을 지원하지 않는다.


  아래의 소스에서는 리스트 자료형을 적절히 사용하였다.

ex는 정수들로 구성된 리스트를 참조하는 변수로, dan은 정수 2를 의미하는 상수로 사용되었다.

es는 구구단의 단을 의미하는 정수(여기서는 2)를 인자로 받아서 출력될 스트링의 리스트를 만드는 함수이다. 'show 인자'는  인자(여기서는 정수)를 스트링으로 변환하는 일을 한다.

printDan은 세 함수 map,  concat , putStr를 합성한 함수로서  스트링의 리스트를
인자로 받아 리스트의 각 요소(스트링) 마다 새줄 문자 "\n"를 붙여서 컨솔에 출력하는 일을 한다. 소스에서 점(.)은 함수의 합성 연산자이다.



소스 파일명: Gugudan.hs
------------------------------[소스 시작]
ex :: [Int]
ex = [1, 2 .. 9]

es :: Int -> [[Char]]
es dd = [ show dd ++ " * " ++ show x ++ " = " ++ show (dd*x) | x <- ex ]

printDan :: [[Char]] -> IO ()
printDan = putStr . concat . map (++"\n")

dan :: Int
dan = 2

main = do printDan (es dan)
------------------------------[소스 끝]


WinHugs의 runhugs.exe를 이용하여 스크립트 소스파일 Gugudan.hs을 실행해 보았다.

실행> runhugs Gugudan.hs
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18

2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18



WinHugs의 대화형 인터프리터 hugs.exe를 이용하여 스크립트 소스파일 Gugudan.hs을 실행해 보았다. 마지막에 :quit는 인터프리터를 종료하는 명령이다. 즉, Ctrl+Z 키를 누른 경우와 같다.


실행> hugs
__   __ __  __  ____   ___      _________________________________________
||   || ||  || ||  || ||__      Hugs 98: Based on the Haskell 98 standard
||___|| ||__|| ||__||  __||     Copyright (c) 1994-2005
||---||         ___||           World Wide Web: http://haskell.org/hugs
||   ||                         Bugs: http://hackage.haskell.org/trac/hugs
||   || Version: 20051031       _________________________________________

Haskell 98 mode: Restart with command line option -98 to enable extensions

Type :? for help
Hugs> :load Gugudan.hs
Main> main
2 * 1 = 2
2 * 2 = 4
2 * 3 = 6
2 * 4 = 8
2 * 5 = 10
2 * 6 = 12
2 * 7 = 14
2 * 8 = 16
2 * 9 = 18

Main> :quit
[Leaving Hugs]

WinHugs의 GUI 대화형 인터프리터 winhugs.exe를 이용하여 스크립트 소스파일 Gugudan.hs을 실행해 보았다. :cd는 change directory 명령이고 :load는 소스파일 탑재(load) 명령이다.
소스파일이 탑재되고 나면 프롬프트가 Main> 으로 바뀐다. 이는 소스파일에 main 함수가 작성되어 있기 때문이다.

Haskell 언어는 Pascal, C, Java 같은 절차적 언어가 아니라, Lisp 처럼  햠수형 언어이다.

소스 코드를 파일로 저장하여 runghc 나 ghci로 실행하거나, ghc로 컴파일하려면, 소스 코드에
main =
부분이 꼭 있어야 한다.

Haskell 언어 홈페이지는 www.haskell.org 이다.
여기서는 윈도우용 GHC를 다운로드하여 설치하고 테스트하였다.
(http://hackage.haskell.org/platform/에서 HaskellPlatform-2009.2.0.2-setup.exe를 다운로드하여 설치해도 된다.)

Hugs 홈페이지(http://www.haskell.org/hugs/)에서 WinHugs-Sep2006.exe (14 MB)를 다운로드하여 설치해도 된다.


컨솔에 문자열 출력하는 Haskell 구문은

       putStrLn "문자열(스트링)"
과
       putStr "문자열(스트링)"

이다. putStrLn 구문은 개행 문자 "\n" 없이 개행하지만, putStr 구문은 개행 문자 "\n"를 추가해야 개행한다.



파일명: hello.hs
------------------------------[소스 시작]
main = putStrLn "Hello, world!"
------------------------------[소스 끝]

대화형 인터프리터 ghci로 실행하기:

실행> ghci hello.hs
GHCi, version 6.10.1: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer ... linking ... done.
Loading package base ... linking ... done.
Ok, modules loaded: Main.
Prelude Main> main
Hello, world!
Prelude Main> ^Z
Leaving GHCi.

위에서 ^Z는 인터프리터 ghci를 종료하기 위해 Ctrl+Z키를 누른 것이다.



컴파일하지 않고 runghc로 실행하기:

실행> runghc hello
Hello, world!

또는

실행> runghc hello.hs
Hello, world!


컴파일러 ghc로 컴파일한 후 실행하기:

컴파일> ghc --make hello.hs
실행> hello
Hello, world!

또는

컴파일> ghc -o hello hello.hs
실행> hello
Hello, world!

또는

컴파일> ghc hello.hs
실행> main
Hello, world!



  WinHugs의 경우 runhugs 명령을 이용하면 타 스크립팅 언어(예를 들어, Python 또는 Ruby)의 실행기 처럼 스크립트 소스파일을 실행시킬 수 있다. GHC는 한글 출력이 안되지만, runhugs는 한글 출력도 잘 된다. 성능은 GHC가 좋겠지만, Haskell 언어를 처음 접하는 경우에는 WinHugs를 이용하는 것이 좋다고 본다.


실행> runhugs hello.hs
Hello, world!


WinHugs의 hugs 명령은 GHC의 대화형 인터프리터 ghci에 해당한다.

실행> hugs
__   __ __  __  ____   ___      _________________________________________
||   || ||  || ||  || ||__      Hugs 98: Based on the Haskell 98 standard
||___|| ||__|| ||__||  __||     Copyright (c) 1994-2005
||---||         ___||           World Wide Web: http://haskell.org/hugs
||   ||                         Bugs: http://hackage.haskell.org/trac/hugs
||   || Version: 20051031       _________________________________________

Haskell 98 mode: Restart with command line option -98 to enable extensions

Type :? for help
Hugs> :load hello.hs
Main> main
Hello, world!

Main> putStr "한글"
한글
Main> ^Z
[Leaving Hugs]


위에서 마지막에 ^Z는 Ctrl+Z 키를 눌러 hugs 를 종료한 것이다.


  다음은 그래픽 사용자 환경(GUI)을 지원하는 winhugs.exe를 실행하여 한글을 출력시켜 본 것이다.  ++는 스트링을 연결(concatenation) 연산자이며, putStrLn ( ...... ) 처럼 소괄호를 둘러싼 것은 연결된 스트링이 출력 대상이기 때문이다, 소괄호로 둘러싸지 않으면 Haskell 구문 에러이다.

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

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

다음은 세 개의 Public 클래스로 구성되어 있다. 각 클래스는 별도의 파일로 저장되어야 한다.
이 예제는 C#용으로 제공된 클래스 상속 예제와의 비교를 위해 제공된다.
(Java와는 달리) 하나의 Visual Basic 소스파일에 public 클래스가 여러 개 존재해도 된다. 소스파일명도 Public 클래스명과 달라도 된다. (비스크립트형) Visual Basic 언어는 소스 코드에서 C, C++, C#, Java  언어 처럼 대소문자 구별을 엄격히 한다.

Parent는 부모 클래스이고 Child는 Parent에서 상속 받은 자식 클래스이다.


컴파일하는 명령은 

     vbc TestSubclassing.bas Parent.bas Child.bas

이다.

실행> TestSubclassing
I am a child, named as Dooly

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

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

[파일명:  TestStringFindInList.cpp]------------------------------------------------
// Filename: TestStringFindInList.cpp
//
// Compile: cl /clr TestStringFindInList.cpp
// Execute: TestStringFindInList

#using <mscorlib.dll>
#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;

void PrintArray(List<String^>^ arr);

bool Contains(String^ s)
{
    return s->IndexOf("셋") >= 0;
}

int main(array<String^> ^args) {
    List<String^>^ words = gcnew List<String^>( gcnew array<String^> { "하나", "둘", "셋", "넷", "다섯", "여섯" } );
    int where;

    Console::Write("list: ");
    PrintArray(words);
    where = words->FindIndex(gcnew Predicate<String^>(Contains));
    if (where >= 0) {
        Console::Write("발견!  ");
        Console::WriteLine("Next word of 셋 in list: {0}", words[where+1]);
    }

    Console::WriteLine("Sorting...");
    words->Sort();

    Console::Write("list: ");
    PrintArray(words);
    where = words->FindIndex(gcnew Predicate<String^>(Contains));
    if (where >= 0) {
        Console::Write("발견!  ");
        Console::WriteLine("Next word of 셋 in list: {0}", words[where+1]);
    }

    return 0;
}
  
void PrintArray(List<String^>^ arr) {
    Console::Write("[");
    for (int i = 0; i < arr->Count - 1; i++) {
        Console::Write("{0}, ", arr[i]);
    }
    if (arr->Count > 0)
        Console::Write("{0}", arr[arr->Count - 1]);
    Console::WriteLine("]");
}
------------------------------------------------


컴파일> cl /clr testStringFindInList.cpp

실행> TestStringFindInList
list: [하나, 둘, 셋, 넷, 다섯, 여섯]
발견!  Next word of 셋 in list: 넷
Sorting...
list: [넷, 다섯, 둘, 셋, 여섯, 하나]
발견!  Next word of 셋 in list: 여섯

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

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

[파일명:  TestStringFindApp.cpp]------------------------------------------------
// Filename: TestStringFindApp.cpp
//
// Compile: cl /clr TestStringFindApp.cpp
// Execute: TestStringFindApp

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;

void PrintArray(array<String^>^ arr);

bool Contains(String^ s)
{
    return s->IndexOf("셋") >= 0;
}

int main(array<String^> ^args) {
    array<String^>^ words = gcnew array<String^> { "하나", "둘", "셋", "넷", "다섯", "여섯" };
    int where;

    Console::Write("array: ");
    PrintArray(words);
    where = Array::FindIndex(words, gcnew Predicate<String^>(Contains));
    if (where >= 0) {
        Console::Write("발견!  ");
        Console::WriteLine("Next word of 셋 in array: {0}", words[where+1]);
    }

    Console::WriteLine("Sorting...");
    Array::Sort(words);

    Console::Write("array: ");
    PrintArray(words);
    where = Array::FindIndex(words, gcnew Predicate<String^>(Contains));
    if (where >= 0) {
        Console::Write("발견!  ");
        Console::WriteLine("Next word of 셋 in array: {0}", words[where+1]);
    }

    return 0;
}
  
void PrintArray(array<String^>^ arr) {
    Console::Write("[");
    for (int i = 0; i < arr->Length - 1; i++) {
        Console::Write("{0}, ", arr[i]);
    }
    if (arr->Length > 0)
        Console::Write("{0}", arr[arr->Length - 1]);
    Console::WriteLine("]");
}
------------------------------------------------


컴파일> cl /clr testStringFindApp.cpp

실행> TestStringFindApp
array: [하나, 둘, 셋, 넷, 다섯, 여섯]
발견!  Next word of 셋 in array: 넷
Sorting...
array: [넷, 다섯, 둘, 셋, 여섯, 하나]
발견!  Next word of 셋 in array: 여섯

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

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

1. // Filename: testArgumentsCli.cpp
2. //
3. // Compile: cl /clr testArgumentsCli.cpp
4. // Execute: testArgumentsCli
6. using namespace System;
8. int main(array<System::String ^> ^args)
9. {
10.     int i;
11.     double sum = 0.0;    // 초기화
13.     // 명령행 인자(command-line argument) 개수 출력
14.     Console::WriteLine("Count of arguments: {0}", args->Length);
16.     for (i = 0; i < args->Length; i++) {
17.         // 스트링을 배정밀도 부동소수점수로 변환하여 누적
18.         sum += Convert::ToDouble(args[i]);
19.     }
21.     // 배정밀도 부동소수점수 값을 출력 
22.     Console::WriteLine("The sum of arguments is {0}", sum);
23.     return 0;
24. }

컴파일> cl /clr testArgumentsCli.cpp

실행> testArgumentsCli 1 2 3 4
Count of arguments: 5
The sum of arguments is 10

실행> testArgumentsCPP 1 2 3 4.1
Count of arguments: 5
The sum of arguments is 10.1






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

C++/CLI는 Visual C++ 2008 부터 등장한 .NET 용 새로운 C++ 프로그램 언어이다.
이는 Visual C++ 2005에 쓰이던 MC++(Mananged C++)의 약점을 보완하며 대체한다.

[참고 자료]
    1. http://www.codeproject.com/KB/mcpp/cppcliintro01.aspx
    2. http://blog.voidnish.com/index.php?p=11
    3. http://recoverlee.tistory.com/37?srchid=BR1http%3A%2F%2Frecoverlee.tistory.com%2F37


 
------------------------------[소스 시작]
// Filename: helloWorldCli.cpp
//
// Compile: cl /clr helloWorldCli.cpp
// Execute: helloWorldCli

using namespace System;
 
int main(array<System::String ^> ^args)
{
    Console::WriteLine("Hello, world!");
    Console::WriteLine("안녕하세요?");
    return 0;
}
------------------------------[소스 끝]


컴파일> cl /clr helloWorldCli.cpp
실행> helloWorldCli
Hello, world!
안녕하세요?

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

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