# 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
def Say(vartype,text):
if vartype=='normal':
print text
if vartype=='var':
def Set(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
try:
x=var+1
line+=functlines
except TypeError:
pass
def IfInt(var1,functlines):
global line
try:
x=var+1
pass
except TypeError:
line+=functlines
def Convert(var):
if type(val) == type('str'):
val=int(val)
if type(val) == type(1):
val=str(val)
def If(var1,compare,var2,functlines):
global line
if compare=='equ':
if var1==var2:
pass
else:
line+=functlines
if compare=='lss':
if var1<var2:
pass
else:
line+=functlines
if compare=='gtr':
if var1>var2:
pass
else:
line+=functlines
def ChangeVar(var,operation,do):
if operation=='+':
val+=do
if operation=='-':
val-=do
if operation=='/':
val/=do
if operation=='*':
val*=do
def CombineVars(newvar,var1,var2,operation):
if operation=='+':
val=var1+var2
if operation=='-':
val=var1-var2
if operation=='/':
val=var1/var2
if operation=='*':
val=var1*var2
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.

• compiler to interpret - Umm... compilers don't interpret stuff. Please correct such core terminology issues. This should help clear it up. – Tamoghna Chowdhury Apr 5 '16 at 5:16

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):

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.

• I don't mean to be a nuisance, but I am not understanding how to use the pasrsers.. would you mind explaining how I transcode that to interpret my own syntax? I read up on all the pages you've suggested.. and it isn't making sense. – Sam Tubb Jan 19 '14 at 1:58
• @Sam, I started to, but it's too big a subject. I think I would recommend starting with a recursive descent compiler, though. That's the simplest thing. – Wayne Conrad Jan 19 '14 at 2:43
• @SamTubb How to use parsers? "The GOLD Parsing System" is a parser which doesn't have a python engine but which IMO has good documentation: the overview is that you a) define a "grammar" for your language; b) feed the grammar, plus some text (e.g. "source code" or "script") written into the language, into the parser c) the parser outputs an "abstract syntax tree" version, which is (theoretically) easier for you to process than the original script text. The grammar syntax is parser-specific. – ChrisW Jan 19 '14 at 15:52
• I understand now! But I think I'm just going to stick to my method for now. Maybe if this ever becomes serious I'll use pyPeg, I like that one. – Sam Tubb Jan 19 '14 at 19:06

It is a beginning. But currently your code is just a thin wrapper around Python function calls. And of course, there is a security problem with "eval", because someone could format your harddisk with the right line, if you execute scripts from untrusted sources.

Maybe you should invent a nice syntax for your language. An easy method to write a parser for it, would be a top-down parser (or recursive descent parser), for simple expressions as demonstrated here.

Later, you could even build a parser tree and convert it to assembly. The so-called "dragon book" is the best reference, if you want to know more about building parsers and compilers.

• I've heard people recommend "the dragon book" but didn't find it practical. Perhaps more practical if you want to write a parser is to learn to use a well-known tool like "YACC"; or I chose a less-well-known but perhaps-easier tool, the "GOLD Parsing System". They're for parsing relatively complicated programming languages, though. – ChrisW Jan 18 '14 at 22:16
• I might suggest one of the Modern Compiler Design in [ML|C|Java] by A. Appel slightly more direct books and just as rewarding for most – jozefg Jan 19 '14 at 5:12
• I think I'm just going to stick to the thin wrapper for now, thank you for your help though. At least I learned something from this. – Sam Tubb Jan 19 '14 at 12:57