Hello. I'm trying to make a simple language in Python. I have many functions, that handle arguments, and execute the commands. Although, the old way I was actually CALLING these functions was to have a dictionary of all the keywords to functions, and then get() it. Is these an easier way to do this?

Alright. I have lots of functions, like so; (BTW VarParser is a little module I made)

import VarParser

def echocmd(cmd, variables):
    if cmd.__len__() < 2:
        print "Too little arguments! echo <string>"
    else:
        xprint = ""
        for i in cmd:
            if i != "echo":
                xprint = xprint + str(VarParser.Parse(i, variables))

        print xprint
        variables['_'] = xprint

def varcmd(cmd, variables):
    if cmd.__len__() < 3:
        print "Too little arguments! str <var> <string>"
    else:
        try:
            varlay = ""
            for i in cmd:
                if cmd.index(i) > 1:
                    try:
                        varlay = varlay + str(VarParser.Parse(i, variables))
                    except:
                        print "Error!"
            variables[cmd[1]] = varlay
        except:
            print "Incorrect syntax! str <var> <string>"

def intcmd(cmd, variables):
    try:
        variables[cmd[1][1:]] = int(variables[cmd[1][1:]])
    except:
        print "Incorrect syntax, or variable does not exist!"

def mathcmd(cmd, variables):
    try:
        if(cmd[2] == "+"):
            xmath = (float(VarParser.Parse(cmd[1], variables))) + (float(VarParser.Parse(cmd[3], variables)))
            print xmath
            variables['_'] = xmath
        elif(cmd[2] == "-"):
            xmath = (float(VarParser.Parse(cmd[1], variables))) - (float(VarParser.Parse(cmd[3], variables)))
            print xmath
            variables['_'] = xmath
        elif(cmd[2] == "*"):
            xmath = (float(VarParser.Parse(cmd[1], variables))) * (float(VarParser.Parse(cmd[3], variables)))
            print xmath
            variables['_'] = xmath
        elif(cmd[2] == "/"):
            xmath = (float(VarParser.Parse(cmd[1], variables))) / (float(VarParser.Parse(cmd[3], variables)))
            print xmath
            variables['_'] = xmath
    except:
        print "Incorrect synatx, or variable(s) do not exist!"      
def exit(cmd, variables):
    prompt = raw_input("Are you sure you want to exit? (y/n) ")
    if prompt == "y":
        variables['exitmode'] = 1
        quit()

def invalidcmd(cmd, variables):
    print "Unknown command! Typed \"help\" for help!"

I'm having trouble calling those functions.

Previously, I was using this to call functions

funcdict = { 'echo' : Functions.echocmd,
             'var'  : Functions.varcmd,
             'exit' : Functions.exit,
             'int'  : Functions.intcmd,
             'math' : Functions.mathcmd,
             'help' : helpcmd}

funcdict.get(TypedCmd[0], Functions.invalidcmd)(TypedCmd, variables)

but that is annoying, how I have to list everything I have.

I would like to make that easier on me.

One way is to register command handler functions with a decorator:

FUNCDICT = dict()

def cmd_handler(func):
    assert func.__name__.endswith('cmd')
    FUNCDICT[func.__name__[:-3]] = func
    return func

@cmd_handler
def echocmd(...):
    ...

@cmd_handler
def catcmd(...):
    ...

# etc

Functions are automatically added to FUNCDICT as you write them.

Did you read about the standard module cmd ? See also this code snippet which is very easy to use.

Edited 4 Years Ago by Gribouillis

This question has already been answered. Start a new discussion instead.