Commands.py

from tkinter import *

class Commands:

    def __init__(self, OutputArea):
        self.OutputArea = OutputArea
        self.INPUTCMD = 'INPUT'
        self.OUTPUTCMD = 'OUTPUT'
        self.DECLARECMD = 'DECLARE'
        self.OutputArea.tag_config('Error', foreground="red")
        self.IFCMD = "IF"
        self.input_pending = False
        self.OutputArea.tag_config('Error', foreground="red")

    def beginsWith(self, value, prefix):
         return value.startswith(prefix)
    
    def outputCommand(self, command):
        value = command[len(self.OUTPUTCMD) + 1:]
        items = value.split(",")
        newItems = []
        for item in items:
            newItems.append('str(' + item + ')')
        items = newItems
        final = "+".join(items)
        self.addLine("output = " + final)
        self.addLine("self.OutputArea.insert(END, output + '\\n')")
    
    def inputReceived(self, event):
        self.inputValue = (self.OutputArea.get(str(self.inputLine) + ".0", END))[:-1]
        self.input_pending = False

    def inputCommand(self, command):
        self.name = command[len(self.INPUTCMD) + 1:]
        self.addLine("self.inputLine = self.OutputArea.index('end-1c').split('.')[0]")
        self.addLine("self.OutputArea.bind('<Return>', self.inputReceived)")
        self.addLine("self.input_pending = True\nwhile self.input_pending:")
        self.addLine("  self.OutputArea.update()")
        self.addLine(self.name + "= self.inputValue")

    def ifCommand(self,command):
        self.condition = command[len(self.IFCMD) + 1:]
        self.addLine("if "+self.condition + ':')
        self.needNext = (self.indent * '\t') + '  THEN'
        self.permittedIndent = True
        self.scopes.append(('\t' * self.indent) + 'ENDIF')
        self.ifSteps.append(1)

    def decodeLine(self, command):
        newCommand = command.lstrip()
        print(command, len(command), newCommand, len(newCommand))
        self.newIndex = len(command) - len(newCommand)
        self.newIndent = command.count('\t') - newCommand.count('\t')
        print("COUNTS", newCommand, command, newCommand.count('\t'), command.count('\t'))
        self.indexDifference = self.newIndex - self.index
        self.indentDifference = self.newIndent - self.indent
        if self.indentDifference != 0 or self.indexDifference != 0:
            self.haveIndented = True
        print("OLD", self.indent, self.index)
        self.indent = self.newIndent
        self.index = self.newIndex
        command = newCommand
        print("HERE")
        print(self.indent, self.index, command, self.scopes, self.indentDifference)
        if self.beginsWith(command, self.OUTPUTCMD + ' '):
            self.outputCommand(command)
        elif self.beginsWith(command, self.INPUTCMD + ' '):
            self.inputCommand(command)
        elif self.beginsWith(command, self.IFCMD + ' '):
            self.ifCommand(command)
        
        elif self.scopes != [] and command == self.scopes[-1] and self.indentDifference == -1:
            if 'ENDIF' in self.scopes[-1] :
                self.ifSteps.pop()
            self.scopes.pop()
            self.permittedIndent = True
        elif self.ifSteps != [] and self.ifSteps[-1] == 1 and self.indexDifference == -2:
            self.ifSteps[-1] == 2
            self.specificIndent = self.indent-1
            print(self.specificIndent)
        else:
            print("Not made yet")

    def addLine(self,line):
        self.finalCode +=  (self.indent * '\t') + line + '\n'

    def errorDetected(self, reason):
        print(self.finalCode)
        self.finalCode = "self.OutputArea.insert(END, 'Error: ["+reason+"]', 'Error')"
        

    def runCode(self, lines):
        self.OutputArea.delete("1.0", END)
        self.needNext = False
        self.indent = 0
        self.index = 0
        self.input_pending = False
        self.finalCode = ''
        self.haveIndented = False
        self.permittedIndent = False
        self.specificIndent = -1
        self.scopes = []
        self.ifSteps = []
        for command in lines:
            if self.needNext == False:
                self.decodeLine(command)
                if self.haveIndented == True:
                    print(self.permittedIndent, self.indent)
                    if self.permittedIndent == False and self.indent != self.specificIndent:
                        self.errorDetected('Indentation Error')
                        break
                    else:
                        self.haveIndented = False
                        self.permittedIndent = False
                    
            else:
                if command != self.needNext:
                    self.errorDetected('IF should be followed by THEN with a TWO spaced indent')
                    break
                else:

                    self.needNext = False
        print(self.finalCode)
        exec(self.finalCode, globals(), {'self': self})

# from tkinter import *

# class Commands:

#     def __init__(self, OutputArea):
#         self.OutputArea = OutputArea
#         self.INPUTCMD = 'INPUT'
#         self.OUTPUTCMD = 'OUTPUT'
#         self.DECLARECMD = 'DECLARE'
#         self.input_pending = False
#         self.OutputArea.tag_config('Error', foreground="red")

#     def nonStringToString(self, value):
#         value = value.strip()
#         # NUMBER ?
#         try:
#             float(value)
#             return str(value)
#         except:
#             # VARIABLE ? 
#             if value in self.variables:
#                 return self.variables[value]
#             else:
#                 print("here", value)
#                 self.error = True
#                 return False

#     def lineToString(self, line):
#         values = []
#         temp = ''
#         status = False
#         for character in line:
#             if character == "\"":
#                 if not status:
#                     status = True
#                     temp = ""
#                 else:
#                     values.append(temp)
#                     temp = ''
#             else:
#                 if character == ',':
#                     if not status:
#                         values.append(self.nonStringToString(temp))
#                         temp = ''
#                     else:
#                         status = False
#                 else:
#                     temp += character
#         if temp != "":
#             values.append(self.nonStringToString(temp))
#         print(values)
#         if False not in values:
#             return "".join(values)
#         else:
#             return False

#     def cmdOutput(self, command):
#         value = command[len(self.OUTPUTCMD) + 1:]
#         outputString = self.lineToString(value)
#         if outputString != False:
#             self.OutputArea.insert(END, outputString + '\n')
#         else:
#             self.OutputArea.insert(END, 'Error in output value', 'Error')

#     def cmdDeclare(self, command):
#         value = command[len(self.OUTPUTCMD) + 1:]
#         name,type = value.split(':')


#     def cmdAssignment(self, name, value):
#         self.variables[name] = value

#     def inputReceived(self, event):
#         inputValue = (self.OutputArea.get(str(self.inputLine) + ".0", END))[:-1]
#         self.variables[self.name] = inputValue
#         print(self.variables)
#         self.input_pending = False

#     def cmdInput(self, command):
#         self.name = command[len(self.INPUTCMD) + 1:]
#         self.inputLine = self.OutputArea.index('end-1c').split('.')[0]
#         self.OutputArea.bind('<Return>', self.inputReceived)
#         self.input_pending = True  

#     def beginsWith(self, value, prefix):
#         return value.startswith(prefix)

#     def decipherCmd(self, command):
#         if self.beginsWith(command, self.OUTPUTCMD + ' '):
#             self.cmdOutput(command)
#         elif self.beginsWith(command, self.INPUTCMD + ' '):
#             self.cmdInput(command)
#         elif self.beginsWith(command, self.DECLARECMD + ' '):
#             self.cmdDeclare(command)

#     def runCmd(self, command):
#         self.decipherCmd(command)

#     def runCode(self, lines):
#         self.OutputArea.delete("1.0", END)
#         self.variables = {}
#         self.error = False
#         for line in lines:
#             if not self.error:

#                 self.runCmd(line)

#                 while self.input_pending:
#                     self.OutputArea.update()