Making my own programming language This question is really to help me decide on something.  I have started development of my own programming language that I am calling DeliciousWaffle (or maybe samscript).

So far it looks pretty cool.  I built a compiler in Python, and associated .dw files with it.  These files are like .py or .vbs or .java.  They provide the code for the compiler to interpret. I also programmed an IDE for it using wxPython.

Here are a few examples of what it looks like:

The fully functional IDE:



A calculator program that I wrote in DeliciousWaffle:



And here is the code for the compiler.  You can download this if you'd like and try out the syntax.

#deliciouswaffle
import sys
import linecache
varss={}
def Say(vartype,text):
    if vartype=='normal':
        print text
    if vartype=='var':
        print varss.get(str(text))
def Set(var,val):
    global varss
    varss.update({str(var):val})
def Get(var,prmpt):
    val=raw_input(prmpt)
    try:
        val=int(val)
        x=val+1
    except:
        val=str(val)
    Set(var,val)
def Loop():
    global line
    line=0
def IfStr(var1,functlines):
    global line
    var=varss.get(var1)
    try:
        x=var+1
        line+=functlines
    except TypeError:
        pass
def IfInt(var1,functlines):
    global line
    var=varss.get(var1)
    try:
        x=var+1
        pass
    except TypeError:
        line+=functlines
def Convert(var):
    val=varss.get(var)
    if type(val) == type('str'):
        val=int(val)
    if type(val) == type(1):
        val=str(val)
    varss.update({var:val})
def If(var1,compare,var2,functlines):
    global varss
    global line
    var1=varss.get(str(var1))
    var2=varss.get(str(var2))
    if compare=='equ':
        if var1==var2:
            pass
        else:
            line+=functlines
    if compare=='lss':
        if var1&lt;var2:
            pass
        else:
            line+=functlines
    if compare=='gtr':
        if var1&gt;var2:
            pass
        else:
            line+=functlines
def ChangeVar(var,operation,do):
    global varss
    val=varss.get(var)
    if operation=='+':
        val+=do
    if operation=='-':
        val-=do
    if operation=='/':
        val/=do
    if operation=='*':
        val*=do
    varss.update({var:val})
def CombineVars(newvar,var1,var2,operation):
    global varss
    var1=int(varss.get(var1))
    var2=int(varss.get(var2))
    if operation=='+':
        val=var1+var2
    if operation=='-':
        val=var1-var2
    if operation=='/':
        val=var1/var2
    if operation=='*':
        val=var1*var2
    varss.update({newvar:val})
def End():
   global eof
   eof=1
line=0
eof=0

try:
    program = (sys.argv[1])
except:
    program = 'main.dw'

if program == 'main.dw':
    try:
        f=open('main.dw','r')
        f.close()
    except:
        print 'No Delicious Waffle script loaded.'
        print 'Create a script called main.dw, or load one into Delicious Waffle.'
        raw_input()
        sys.exit()

while eof==0:
    try:
        line+=1
        try:
            eval(linecache.getline(program, line))
        except:
            pass
    except:
        eof=1
        f=open('tempvars.file','w')
        f.close()
        sys.exit()


What do you think?  Is this worth completing?  Or should I leave it be?  This question is probably inappropriate for code review, sorry.
I second the recommendation to invent a grammar and use a real parser.  A recursive descent parser is very easy to write, and a great place to start.  You might also have a look at a PEG (Parsing Expression Grammar).  It's almost as easy to use a PEG as it is to write a recursive descent compiler, and a PEG can parse more grammars than can a recursive descent compiler.
Here are two PEGs for Python (I haven't used either of them, so can't vouch for them):


pyPeg
parsimonious


I don't see a good reason to get the Dragon book yet.  Much of what it teaches is how to write the LEXX/YACC type tools, along with language theory.  I think it's too deep and too low level for someone who just wants to try creating a language in order to see how it's done.  If, however, you do want to dive that deep, it is a very good book.

I would, for now, steer clear of a traditional lex/yacc setup.  That's a harder road that can wait until you've had some experience with simpler schemes.  However, if you do want to go there, PLY is a lex/yacc type parser for Python.