अपनी स्वयं की प्रोग्रामिंग भाषा बनाने के इस भाग में, हम नेस्टेड कक्षाओं को लागू करके और पिछले भाग में पेश की गई कक्षाओं को थोड़ा उन्नत करके अपनी भाषा में सुधार करना जारी रखेंगे। कृपया पिछले भागों को देखें: स्क्रैच से अपनी खुद की प्रोग्रामिंग लैंग्वेज बनाना स्क्रैच से अपनी खुद की प्रोग्रामिंग लैंग्वेज बनाना: भाग II - दिज्क्स्ट्रा का टू-स्टैक एल्गोरिथम बिल्ड योर ओन प्रोग्रामिंग लैंग्वेज पार्ट III: इम्प्रूविंग लेक्सिकल एनालिसिस विथ रेगेक्स लुकहेड्स स्क्रैच भाग IV से अपनी खुद की प्रोग्रामिंग लैंग्वेज बनाना: कार्यों को लागू करना स्क्रैच से अपनी खुद की प्रोग्रामिंग लैंग्वेज बनाना: भाग V - सारणियाँ स्क्रैच से अपनी खुद की प्रोग्रामिंग लैंग्वेज बनाना: भाग VI - लूप्स स्क्रैच से अपनी खुद की प्रोग्रामिंग लैंग्वेज बनाना: भाग VII - कक्षाएं पूरा स्रोत कोड उपलब्ध है। GitHub पर 1 शाब्दिक विश्लेषण पहले खंड में, हम शाब्दिक विश्लेषण को कवर करेंगे। संक्षेप में, यह स्रोत कोड को भाषा के शब्दों में विभाजित करने की एक प्रक्रिया है, जैसे कि कीवर्ड, चर, ऑपरेटर, आदि। आपको पिछले भागों से याद हो सकता है कि मैं टोकन टाइप एनम में सूचीबद्ध रेगेक्स एक्सप्रेशन का उपयोग सभी प्रकारों को परिभाषित करने के लिए कर रहा था: लेक्सेम package org.example.toylanguage.token; public enum TokenType { Comment("\\#.*"), LineBreak("[\\n\\r]"), Whitespace("[\\s\\t]"), Keyword("(if|elif|else|end|print|input|class|fun|return|loop|in|by|break|next)(?=\\s|$)"), GroupDivider("(\\[|\\]|\\,|\\{|}|[.]{2})"), Logical("(true|false)(?=\\s|$)"), Numeric("([-]?(?=[.]?[0-9])[0-9]*(?![.]{2})[.]?[0-9]*)"), Null("(null)(?=,|\\s|$)"), This("(this)(?=,|\\s|$)"), Text("\"([^\"]*)\""), Operator("(\\+|-|\\*|/{1,2}|%|>=|>|<=|<{1,2}|={1,2}|!=|!|:{2}|\\(|\\)|(new|and|or)(?=\\s|$))"), Variable("[a-zA-Z_]+[a-zA-Z0-9_]*"); private final String regex; } आइए इस नेस्टेड क्लास प्रोटोटाइप को देखें, और लापता रेगेक्स एक्सप्रेशन को हमारे में जोड़ें: TokenType जब हम नेस्टेड क्लास का एक उदाहरण बनाते हैं, तो हम निम्नलिखित निर्माण का उपयोग दो भावों और उनके बीच एक ऑपरेटर के साथ करते हैं: बायाँ एक्सप्रेशन उस क्लास का एक उदाहरण है जिससे हम एक नेस्टेड क्लास प्राप्त करने की बात कर रहे हैं। सही अभिव्यक्ति एक नेस्टेड वर्ग है जिसमें एक उदाहरण बनाने के गुण हैं। class_instance NestedClass [args] अंत में, एक नेस्टेड क्लास बनाने के लिए एक ऑपरेटर के रूप में, मैं निम्नलिखित एक्सप्रेशन का उपयोग करूंगा: , जिसका अर्थ है कि हम क्लास इंस्टेंस प्रॉपर्टी को दो कोलन ऑपरेटर के साथ संदर्भित करते हैं, और फिर हम के साथ एक इंस्टेंस बनाते हैं ऑपरेटर। :: new :: new लेक्सम के वर्तमान सेट के साथ, हमें केवल ऑपरेटर के लिए एक नियमित अभिव्यक्ति जोड़ने की आवश्यकता है। इस ऑपरेटर को निम्नलिखित रेगेक्स अभिव्यक्ति द्वारा मान्य किया जा सकता है: :: new :{2}\\s+new चलिए इस एक्सप्रेशन को लेक्सेम में OR एक्सप्रेशन के रूप में जोड़ते हैं क्लास प्रॉपर्टी तक पहुँचने के लिए खड़ा हिस्सा: Operator :{2} public enum TokenType { ... Operator("(\\+|-|\\*|/{1,2}|%|>=|>|<=|<{1,2}|={1,2}|!=|!|:{2}\\s+new|:{2}|\\(|\\)|(new|and|or)(?=\\s|$))"), ... } 2 सिंटेक्स विश्लेषण दूसरे खंड में, हम अपने भाषा नियमों का पालन करते हुए शाब्दिक विश्लेषक से प्राप्त शब्दांशों को अंतिम कथनों में परिवर्तित करेंगे। 2.1 ऑपरेटर एक्सप्रेशन गणित के भावों का मूल्यांकन करने के लिए, हम उपयोग कर रहे हैं। इस एल्गोरिथम में प्रत्येक ऑपरेशन को एक यूनरी ऑपरेटर द्वारा एक ऑपरेंड के साथ या एक बाइनरी ऑपरेटर द्वारा क्रमशः दो ऑपरेंड के साथ प्रस्तुत किया जा सकता है: दिज्क्स्ट्रा के टू-स्टैक एल्गोरिथम का नेस्टेड क्लास का इन्स्टेन्शियशन एक बाइनरी ऑपरेशन है जहाँ लेफ्ट ऑपरेंड एक क्लास इंस्टेंस है जिसका उपयोग हम उस क्लास को संदर्भित करने के लिए करते हैं जहाँ नेस्टेड क्लास को परिभाषित किया गया है, और दूसरा ऑपरेंड एक नेस्टेड क्लास है जिसका हम एक इंस्टेंस बनाते हैं: चलिए विस्तार करके कार्यान्वयन बनाते हैं NestedClassInstanceOperator : बाइनरीऑपरेटर एक्सप्रेशन package org.example.toylanguage.expression.operator; public class NestedClassInstanceOperator extends BinaryOperatorExpression { public NestedClassInstanceOperator(Expression left, Expression right) { super(left, right); } @Override public Value<?> evaluate() { ... } } अगला, हमें विधि को पूरा करना चाहिए जो नेस्टेड क्लास इंस्टेंटेशन करेगा: evaluate() सबसे पहले, हम बाएं ऑपरेंड की अभिव्यक्ति का अभिव्यक्ति में मूल्यांकन करते हैं: Value @Override public Value<?> evaluate() { // ClassExpression -> ClassValue Value<?> left = getLeft().evaluate(); } अगला, हमें सही ऑपरेंड का करने की आवश्यकता है। इस मामले में, हम सीधे आह्वान नहीं कर सकते क्योंकि नेस्टेड क्लास की परिभाषा मूल वर्ग की परिभाषास्कोप (बाएं ऑपरेंड में) में घोषित की जाती है। evaluate() Expression#evaluate() नेस्टेड कक्षाओं की परिभाषाओं तक पहुँचने के लिए, हमें एक सहायक विधि बनानी चाहिए, जो बाएं ऑपरेंड को ले लेगी और नेस्टेड क्लास की परिभाषा तक पहुँचने के लिए इसके डेफिनिशनस्कोप का उपयोग करेगी और इसका एक उदाहरण बनाएगी: ClassExpression#evaluate(ClassValue) @Override public Value<?> evaluate() { Value<?> left = getLeft().evaluate(); if (left instanceof ClassValue && getRight() instanceof ClassExpression) { // instantiate nested class // new Class [] :: new NestedClass [] return ((ClassExpression) getRight()).evaluate((ClassValue) left); } else { throw new ExecutionException(String.format("Unable to access class's nested class `%s``", getRight())); } } अंत में, लापता विधि को लागू करते हैं। ClassExpression#evaluate(ClassValue) यह कार्यान्वयन विधि के समान होगा, केवल अंतर यह है कि हमें नेस्टेड क्लास परिभाषाओं को पुनः प्राप्त करने के लिए सेट करना चाहिए: ClassExpression#evaluate() ClassDefinition#getDefinitionScope() package org.example.toylanguage.expression; … public class ClassExpression implements Expression { private final String name; private final List<Expression> argumentExpressions; @Override public Value<?> evaluate() { //initialize class arguments List<Value<?>> values = argumentExpressions.stream().map(Expression::evaluate).collect(Collectors.toList()); return evaluate(values); } /** * Evaluate nested class * * @param classValue instance of the parent class */ public Value<?> evaluate(ClassValue classValue) { //initialize class arguments List<Value<?>> values = argumentExpressions.stream().map(Expression::evaluate).collect(Collectors.toList()); //set parent class's definition ClassDefinition classDefinition = classValue.getValue(); DefinitionContext.pushScope(classDefinition.getDefinitionScope()); try { return evaluate(values); } finally { DefinitionContext.endScope(); } } private Value<?> evaluate(List<Value<?>> values) { //get class's definition and statement ClassDefinition definition = DefinitionContext.getScope().getClass(name); ClassStatement classStatement = definition.getStatement(); //set separate scope MemoryScope classScope = new MemoryScope(null); MemoryContext.pushScope(classScope); try { //initialize constructor arguments ClassValue classValue = new ClassValue(definition, classScope); ClassInstanceContext.pushValue(classValue); IntStream.range(0, definition.getArguments().size()).boxed() .forEach(i -> MemoryContext.getScope() .setLocal(definition.getArguments().get(i), values.size() > i ? values.get(i) : NullValue.NULL_INSTANCE)); //execute function body DefinitionContext.pushScope(definition.getDefinitionScope()); try { classStatement.execute(); } finally { DefinitionContext.endScope(); } return classValue; } finally { MemoryContext.endScope(); ClassInstanceContext.popValue(); } } } 2.2 ऑपरेटर गणित के भावों का मूल्यांकन करने के लिए हम जिन ऑपरेटरों का उपयोग कर रहे हैं, वे एनम में संबंधित पूर्वता, चरित्र और एक्सप्रेशन प्रकार के साथ संग्रहीत होते हैं, जिसे हम प्रत्येक ऑपरेशन के परिणाम की गणना करने के लिए संदर्भित करते हैं: ऑपरेटर OperatorExpression ... public enum Operator { Not("!", NotOperator.class, 7), ClassInstance("new", ClassInstanceOperator.class, 7), ... private final String character; private final Class<? extends OperatorExpression> type; private final Integer precedence; Operator(String character, Class<? extends OperatorExpression> type, Integer precedence) { this.character = character; this.type = type; this.precedence = precedence; } public static Operator getType(String character) { return Arrays.stream(values()) .filter(t -> Objects.equals(t.getCharacter(), character)) .findAny().orElse(null); } ... } हमारे पास पहले से ही एक नियमित वर्ग के आरंभीकरण के लिए मान है। आइए नेस्टेड क्लास इंस्टेंस को प्रबंधित करने के लिए एक नया मान जोड़ें। ClassInstance नए मान में वही वर्ण अभिव्यक्ति होगी जैसा हमने पहले में परिभाषित किया था और नियमित वर्ग के उदाहरण के समान पूर्वता। NestedClassInstance TokenType ऑपरेटर एक्सप्रेशन प्रकार के लिए, हम पहले से परिभाषित का उपयोग करेंगे: NestedClassInstanceOperator ... public enum Operator { Not("!", NotOperator.class, 7), ClassInstance("new", ClassInstanceOperator.class, 7), NestedClassInstance(":{2}\\s+new", NestedClassInstanceOperator.class, 7), ... } आप देख सकते हैं कि इस नए ऑपरेटर को छोड़कर कैरेक्टर प्रॉपर्टी में हमारे पास रेगेक्स एक्सप्रेशन नहीं हैं। रेगेक्स एक्सप्रेशन का उपयोग करके ऑपरेटर को पढ़ने के लिए, हमें ऑपरेटर को रेगुलर एक्सप्रेशन के साथ मिलान करने के लिए विधि को अपडेट करना चाहिए: NestedClassInstance Operator#getType() public enum Operator { ... public static Operator getType(String character) { return Arrays.stream(values()) .filter(t -> character.matches(t.getCharacter())) .findAny().orElse(null); } ... } अंत में, हमें निम्नलिखित प्रतीकों वाले संचालन के लिए एक वर्ण से पहले दो बैकस्लैश जोड़ना चाहिए: यह सुनिश्चित करने के लिए कि इन वर्णों को रेगेक्स खोज प्रतीकों के रूप में नहीं माना जाता है: \\ +, *, (, ) Multiplication("\\*", MultiplicationOperator.class, 6), Addition("\\+", AdditionOperator.class, 5), LeftParen("\\(", 3), RightParen("\\)", 3), ऑपरेटर को पेश करने के बाद, हमें इसे क्लास में इंजेक्ट करना चाहिए जो वास्तव में ऑपरेंड और ऑपरेटर्स में मैथ एक्सप्रेशंस को पार्स करता है। हमें केवल उस रेखा को खोजने की जरूरत है जहां हम कक्षा का उदाहरण पढ़ते हैं: NestedClassInstance ExpressionReader if (!operators.isEmpty() && operators.peek() == Operator.ClassInstance) { operand = readClassInstance(token); } ऑपरेटर को पढ़ने में सहायता के लिए, हम ऑपरेटर के स्टैक में वर्तमान ऑपरेटर के लिए संबंधित स्थिति जोड़ते हैं: NestedClassInstance if (!operators.isEmpty() && (operators.peek() == Operator.ClassInstance || operators.peek() == Operator.NestedClassInstance)) { operand = readClassInstance(token); } विधि नेस्टेड क्लास की घोषणा को गुणों के साथ उसी तरह पढ़ती है जैसे यह नियमित कक्षा घोषणा को पढ़ती है। यह विधि इंस्टेंस को संपूर्ण ऑपरेंड एक्सप्रेशन के रूप में लौटाती है। readClassInstance() ClassExpression 3. रैप अप सब कुछ अब तैयार है। इस भाग में, हमने नेस्टेड कक्षाओं को एक संपूर्ण प्रोग्रामिंग भाषा बनाने की दिशा में एक और कदम के रूप में लागू किया।
