எழில் (நிரலாக்க மொழி)

**எழில் - ஒரு தமிழ் நிரலாக்க மொழி**
நிரலாக்கக் கருத்தோட்டம்:	பொருள் பெயர்க்கப்பட்டது (Interpreted), கண்டிப்பானது (Imperative), கட்டமைக்கப்பட்டது (Structured)
தோன்றிய ஆண்டு:	2007
வடிவமைப்பாளர்:	முத்து அண்ணாமலை
வளர்த்தெடுப்பாளர்:	தனியார்
அண்மை வெளியீட்டுப் பதிப்பு:	version 0.99
அண்மை வெளியீட்டு நாள்:	23 ஆகத்து 2017; 7 ஆண்டுகள் முன்னர்
இயல்பு முறை:	strong, dynamic
முதன்மைப் பயனாக்கங்கள்:	Ezhil-Lang
பிறமொழித்தாக்கங்கள்:	LOGO, BASIC, Python
கோப்பு நீட்சி:	.n
இயக்குதளம்:	லினக்சு(Linux), மைக்ரோசாப்ட் விண்டோசு(Microsoft Windows),பைத்தானின்Python's's pip (package manager)பயன்படுத்தி மாக்_இயக்குதளம்(MacOS) இயக்கலாம்
அனுமதி:	GPL v3
இணையதளம்:	ezhillang.org

எழில் (Ezhil), தமிழில் எழுதும்வகையில் உருவாக்கப்பட்டுள்ள நிரலாக்க மொழியாகும்.^[4]. இதில் தமிழ் கலைச் சொற்களைக் கொண்டே நிரல்கள் எழுத முடியும். இது இலவசமாகக் கிடைக்கக்கூடிய ஒரு நிரல் மொழியாகும். இம்மொழி இன்னோர் பிரபல மொழியாகிய பைத்தானு(Python)டன் ஒத்து இயங்கும்படி உருவாக்கப்பட்டுள்ளது. பைத்தானின் நிரலகங்களைப் பயன்படுத்தி இயங்கும் இந்த மொழியில், ஆங்கிலத்திலும் நிரல்களை எழுதமுடியும்.

தற்சமயம் சோதனை அடிப்படையில் வெளியிடப்பட்டுள்ள இந்த மொழி, விரைவில் முழுச் செயல்பாட்டுக்கு வரும் என எதிர்பார்க்கப்படுகிறது.

உருவாக்கக் காரணம்

பெரும்பாலான கணினி நிரல் மொழிகளை எழுத விரும்புவோர், ஆங்கிலம் அறிந்திருக்கவேண்டும். காரணம் அம்மொழிகளுக்குரிய குறிச்சொற்கள் அனைத்தும் ஆங்கிலத்தில் அமைந்துள்ளன. இதனால், ஆங்கிலம் அறியாதோர் அல்லது ஓரளவுமட்டும் அறிந்தோர் நிரலாக்கத்துறையில் சிறந்த நிபுணர்களாகமுடியாதபடி சிரமப்படுகிறார்கள்.

இந்நிலையை மாற்றுவதற்காக, ஆங்கிலம் அறியாதவர்களும் தங்கள் தாய்மொழியில் எளிதாக நிரல்களை எழுதும் வசதியைக் கொண்டுவருவதற்காகப் பலர் முயன்று வருகிறார்கள்.

இவ்வகையில் பிரெஞ்சு, அரபி, உருசியம், யப்பானியம் உள்ளிட்ட பல மொழிகளில் கணினி நிரலாக்க மொழிகள் உருவாக்கப்பட்டுள்ளன. அந்த வரிசையில், எழில் தமிழ் மொழிக்குரிய நிரலாக்க மொழியாக உருவாகியுள்ளது.

குறிக்கோள்கள்

கல்வி: பள்ளி, கல்லூரிகளில் தமிழில் கணினியியல் கற்கும் மாணவர்கள் தங்கள் தாய்மொழியிலேயே கற்க உதவியாக இருத்தல்
இயல்பு: எழில் நிரலாக்க மொழியின் கட்டமைப்பு தமிழ் இலக்கணத்தை ஒத்திருத்தல்

வசதிகள்

கணித, தர்க்கச் (logical) செயல்பாடுகள்
முந்நூற்றைம்பதுக்கும் மேற்பட்ட உள்கட்டமைப்புகள், இவற்றில் பெரும்பாலானவை பைத்தான் மொழியிலிருந்து எடுக்கப்பட்டவை
செயல்முறை நிரலாக்க, மறுநிகழ்வு அழைப்பு (recursion) மூலம் செயல்பாடுகளைப் பயன்படுத்தி நிரல்களை எழுத முடியும். (Procedural programming using functions, supporting recursion, and call-by-value)
எழில் வெறும் மேக்ரோ செயலி (macro-processor) அல்ல; அது ஒரு முழுமையான நிரலாக்க மொழி, முழுமையான தொகுப்பு முகப்பும்(Compiler-Front-End)கூட
Internet based - [இணையதளத்தில்] எழில் நிரல்களை எழுதலாம்
Notepad++ மற்றும் Emacs செயலிகளைப் பயன்படுத்தி எழில் நிரல்களை எழுதலாம்
தமிழில் ஏற்கெனவே ஸ்வரம் என்ற பெயரில் ஒரு நிரலாக்க மொழி உருவாக்கப்பட்டது. ஆனால், பின்னர் அது கைவிடப்பட்டுவிட்டது. எழில் மொழியின் இலக்கணம் அதிலிருந்து கணிசமாக வேறுபட்டு அமைந்துள்ளதைக் காணலாம்

சிறப்பு சொற்கள் (Keywords)

எழில் மொழிக்குரிய சிறப்புச் சொற்கள் ( keywords) வாக்கியங்கள் (statements) அனைத்தும் தமிழ் மொழி இலக்கணத்தின் அதே பாணியை பின்பற்றும்வகையில் தேர்ந்தெடுக்கப்பட்டுள்ளன. எழில் நிரல்கள் LISP போன்றவை : வெளிப்பாட்டை(expression)த் தொடர்ந்து பயனிலை(predicate) அமையும். இது தமிழ் மொழியில் உள்ள சிந்தனை மற்றும் பகுத்தறிவு இயற்கை வழியாகும். இதேபோல், நிபந்தனை வாக்கியங்கள் 'IF, ELSEIF, Else' வாக்கியத்தை மாதிரியாகக் கொண்டவை. வரை-loop பெறப்படும் while-loop கட்டுப்பாட்டு வாக்கியத்தை மாதிரியாகக் கொண்டது. எழில் மொழியின் முக்கியமான வாக்கியங்கள் இங்கே தரப்பட்டுள்ளன:

1.- :  "பதிப்பி" வாக்கியம்  (PRINT)
2.- : "நிறுத்து" வாக்கியம் (BREAK)
3.- : "தொடர்" வாக்கியம் (CONTINUE)
4.- : "பின்கொடு" வாக்கியம் (RETURN)
5.- : "ஆனால்", "இல்லைஆனால்", "இல்லை"  வாக்கியம் (IF-ELSEIF-ELSE)
6.- : "முடி"  வாக்கியம் (END)
7.- : "நிரல்பாகம்" வாக்கியம் (FUNCTION)
8.- : "வரை" வாக்கியம் (WHILE)
9.- : "ஆக","முடியேனில்" வாக்கியம் (DO-WHILE)
10.- : "தேர்ந்தெடு" வாக்கியம் (SELECT)
11.- : "தேர்வு" வாக்கியம் (CASE) 
12.- : "ஒவ்வொன்றாக" வாக்கியம் (FOR-EACH)

தரவு வகை அமைப்பு (Data Type system)

எழில் எண்கள்(Numbers), எழுத்துச் சரங்கள் (Strings), தர்க்கம் (Logical) மற்றும் பட்டியல்கள் (List) என்ற நான்கு அடிப்படை வகைகளைக் கொண்டுள்ளது. இவைதவிர வேறு புதிய வகைகளை நிரல் எழுதுவோர் உருவாக்க இயலாது.

எழில் மொழி இலக்கணம் - கட்டுப்பாடு அமைப்புகள் மற்றும் இயக்கிகள்

எழில் மொழி இலக்கணம் கட்டுப்பாடு அமைப்புகள் மற்றும் இயக்கிகள் கீழே காண்க.

ஆனால்-இல்லை-முடி வாக்கியம் (If-Else statement)

   @( CONDITION ) ஆனால்
      #True branch
   இல்லை
      #False branch
  முடி

வரை-முடி வாக்கியம் (Loop statement)

   @( CONDITION ) வரை
       #LOOP BODY
  முடி

கணித மற்றும் தர்க்க செயற்குறிகள் (Operators)

கணித இயக்கிகள் : +, -, *, /
கணித சிறப்பு இயக்கிகள் : %(மட்டு), ^(படி)
தர்க்க இயக்கிகள் : சமம் (==), சமமின்மை (!=),!,&&,||
கணித ஒப்பீட்டு இயக்கிகள் : >=, <=, >, <

குறிப்புகள் (Comments)

'#' என்ற எழுத்தில் தொடங்கி எழுதப்படும் நிரல் வரிகள், வெறும் குறிப்புகளாகக் கருதப்படும், அவை இயக்கப்படாது, வாசிப்போரின் கவனத்துக்குமட்டும்

நிரல்பாகம் செயல்பாடு(Function declaration)

நிரல்பாகம் [FUNCTION_NAME] ( ARGLIST )
  [FUNCTION BODY]
முடி

பெயர் தெரிவுநிலை (Name Scoping, Visibility)

எழில் நிரல்பாகங்களை மற்ற நிரல் பகுதிகள் அழைக்கும்போது, உரிய மதிப்புடன் அழைக்கவேண்டும் (call-by-value), ஒவ்வொரு நிரல்பாகத்தினுள்ளும் மாறிகளைக் குறிப்பிட்டுப் பயன்படுத்தவேண்டும்.

எழில் நடைமுறைப்படுத்தல்

தற்போதைய எழில் நடைமுறைப்படுத்தல் ^[5] readline போன்ற மென்பொருளை அடிப்படையாகக் கொண்டது [1], இதில் தானாக நிரல்களை எழுதி இயக்க முடியும். இங்கே தமிழில் எழுத UTF-8 தரத்தைப் பயன்படுத்தவேண்டும்.

எடுத்துக்காட்டு நிரல்கள்

அகிலத்துக்கு வணக்கம் (Hello world)

நீங்கள் எழில் தமிழ் நிரலாக்க மொழிமூலம் எளிமையான நிரல்களை எழுதமுடியும்:

# எழில் தமிழ் நிரலாக்க மொழி உதாரணம்

பதிப்பி "அகிலத்துக்கு வணக்கம்!"
பதிப்பி "******* வருகைக்கு நன்றி! *******"

ஊகிக்கும் விளையாட்டு (Guessing game)

இந்த விளையாட்டில் உங்களுக்குப் பத்து வாய்ப்புகள் தரப்படும். அதற்குள், ஒன்றிலிருந்து நூறுக்குள் உள்ள ஓர் எண்ணை நீங்கள் சரியாக ஊகித்து வெற்றி அடையாலாம்!

எண் = randint(1,100)

வாய்ப்பு = 0

@(வாய்ப்பு < 10 ) வரை

   ஊகித்தஎண் = உள்ளீடு ("ஒன்றிலிருந்து நூறுக்குள் உள்ள ஏதோ ஓர் எண்ணை நான் மனத்தில் நினைத்துள்ளேன். அது என்ன என்று உங்களால் ஊகிக்கமுடியுமா? ")

  வாய்ப்பு = வாய்ப்பு + 1

   @( எண் == ஊகித்தஎண் ) ஆனால்
      பதிப்பி "வாழ்த்துக்கள்! சரியான பதில்!"
      exit(0)
   முடி

   @( எண் < ஊகித்தஎண் ) ஆனால்
      பதிப்பி "நீங்கள் சொல்லும் எண் தவறு, நான் நினைத்த எண்ணைவிட அது பெரியது!"
   இல்லை
      பதிப்பி "நீங்கள் சொல்லும் எண் தவறு, நான் நினைத்த எண்ணைவிட அது சிறியது"
  முடி
  
  பதிப்பி "கவலை வேண்டாம், இன்னும் ", (10 - வாய்ப்பு), " வாய்ப்புகள் உள்ளன. நீங்கள் நிச்சயம் வெல்லலாம், மீண்டும் முயற்சி செய்யுங்கள்!"

முடி

பதிப்பி "மன்னிக்கவும், நீங்கள் பத்து வாய்ப்புகளுக்குள் சரியான எண்ணைக் கண்டுபிடிக்கவில்லை!"

கோப்பு உள்ளீடு மற்றும் வெளியீடு (File I/O)

# முதலில், நாம் ஒரு கோப்பைத் திறந்துகொள்ளவேண்டும்
கோப்பு = கோப்பை_திற( "names.txt","w")

# நாம் ஒரு பட்டியலில் இருந்து வார்த்தைகளைப் பயன்படுத்தமுடியும்

எ = ["இந்த","மொழி","எழில்","நிறைந்தது"]
இ = 0
@( இ < நீளம்(எ) ) வரை
  #வார்த்தைகளை அவற்றுக்குரிய எண்களுடன் ஒவ்வொன்றாகக் கோப்பில் எழுதுவோம்
  வரி = str(இ) +" = "+ எடு( எ, இ ) + " \n"
  பதிப்பி வரி
  கோப்பை_எழுது( கோப்பு,வரி )
  இ = இ + 1
முடி

# இப்போது, கோப்பைச் சேமித்து மூட
கோப்பை_மூடு( கோப்பு )

# மூடிய கோப்பை மீண்டும் திறப்போம்
கோப்பு = கோப்பை_திற( "names.txt")

# அதனுள் எழுதப்பட்டுள்ள விஷயங்களைப் படிப்போம்
வரிகள் = கோப்பை_படி(கோப்பு)

# அதனைப் பயனருக்குக் காண்பிப்போம்
பதிப்பி வரிகள்

# பழையபடி கோப்பை மூடிவிடுவோம்
கோப்பை_மூடு( கோப்பு )

ஆமை வரைவியல் (Turtle graphics)

ஆமை வரைவியல் எனும் Turtle graphics பயன்படுத்தி, எழில் மொழியில் சீன யின் யாங் குறியீட்டை வரையலாம்.

நிரல்பாகம் yin(radius, color1, color2)
    #turtle_width(3)
    turtle_color("black")
    turtle_fill(True)
    turtle_circle(radius/2., 180)
    turtle_circle(radius, 180)
    turtle_left(180)
    turtle_circle( -1*radius/2.0 , 180 )
    turtle_color(color1)
    turtle_fill(True)
    turtle_color(color2)
    turtle_left(90)
    turtle_up()
    turtle_forward(radius*0.375)
    turtle_right(90)
    turtle_down()
    turtle_circle(radius*0.125)
    turtle_left(90)
    turtle_fill(False)
    turtle_up()
    turtle_backward(radius*0.375)
    turtle_down()
    turtle_left(90)
முடி

நிரல்பாகம் main()
    #turtle_reset()
    yin(200, "white", "black")
    yin(200, "black", "white")
    turtle_ht()
    pause( "Done! Hit enter to quit", 5)
முடி

main()