#Copyright (C) 2019 Jon Pry

#

#This file is part of Pill.

#

#Pill is free software: you can redistribute it and/or modify

#it under the terms of the GNU General Public License as published by

#the Free Software Foundation, either version 2 of the License, or

#(at your option) any later version.

#

#Pill is distributed in the hope that it will be useful,

#but WITHOUT ANY WARRANTY; without even the implied warranty of

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

#GNU General Public License for more details.

#

#You should have received a copy of the GNU General Public License

#along with Pill. If not, see <http://www.gnu.org/licenses/>.

import inspect

import sys

import os

import re

import props

from tools import Lazy

import klayout.db as db

import klayout.lib

import tools

import math

import context

import geom

import uuid

layout = db.Layout()

layout.dbu = .001

######## These are implementations of Skill standard library functions

def getsqg(*s):

return ret

def setsqg(a,b):

#assert(False)

pass

def stringp(s):

return isinstance(s,str) or isinstance(s,props.StringProperty)

def floatp(s):

return isinstance(s,float)

def fixp(s):

return isinstance(s,int) and not (isinstance(s,bool) or isinstance(s,props.BooleanProperty))

def numberp(s):

return fixp(s) or isinstance(s,float)

def boundp(e):

return e.expr in skill.variables

def greaterp(a,b):

return a > b

def makeTable(name,default):

return tools.SkillTable(name,default)

def mod(a,b):

return a % b

def fix(a):

r = int(math.floor(a))

print("floor: " + str(a) + "=" + str(r))

return r

def dbGet(a,b):

return None

def sprintf(foo,format,*args):

return format.replace("%L","%s") % nargs

def printf(format, *args):

#sys.stdout.write(sprintf(None,format,*args))

def artError(format, *args):

sys.stdout.write(sprintf(None,format,*args))

assert(False)

exit(0)

def listl(*args,**kwargs):

return list(args)

def car(l):

return l

def cadr(l):

return car(cdr(l))

def caar(l):

return car(car(l))

def cadar(l):

return car(cdr(car(l)))

def cadadr(l):

return car(cdr(car(cdr(l))))

def caadr(l):

return car(car(cdr(l)))

def cdr(l):

return l[1:]

def cddr(l):

return cdr(cdr(l))

def cdddr(l):

return cdr(cdr(cdr(l)))

def caddr(l):

return car(cdr(cdr(l)))

def cadddr(l):

return car(cdr(cdr(cdr(l))))

def cddddr(l):

return car(cdr(cdr(cdr(cdr(l)))))

def yCoord(l):

return l[1]

def evalstring(s):

return v

def techGetParam(db,ob):

techParms = { "cadGrid" : 0.005 }

return techParms[ob]

def cdfParseFloatString(s):

return v

def maplayer(layer):

return -1

def rodCreateRectBase(layer,width,length,origin=[0,0],elementsX=1,spaceX=0,termIOType=None,termName=None,pin=None,cvId=None,beginOffset=0,endOffset=0,space=0,subs=None):

return createObj(subs=subs,lpp=layer)

rodsByName = {}

def rodCreateRect(layer,width=0,length=0,origin=[0,0],name="",elementsX=1,elementsY=1,spaceX=0,spaceY=0,termIOType=None,

return objs

def rodTranslate(alignObj,delta,internal=False,done=None):

rodTranslate(s,delta,True,done)

def rodAlign(alignObj,alignHandle,refObj=None,refHandle=None,ySep=0,xSep=0,refPoint=None):

refObj['_slaves'].append(alignObj)

def leftEdge(rod):

if isinstance(rod,list):

return rod[0][0]

return rod['lL'][0]

def topEdge(rod):

if isinstance(rod,list):

return rod[1][0] + rod[1][1]

return rod['uR'][1]

def bottomEdge(rod):

if isinstance(rod,list):

return rod[1][0]

return rod['lL'][1]

def rightEdge(rod):

if isinstance(rod,list):

return rod[0][0] + rod[0][1]

return rod['uR'][0]

def addPoint(a,b):

return [a[0]+b[0],a[1]+b[1]]

def subPoint(a,b):

return [a[0]-b[0],a[1]-b[1]]

def maxNinN(limit,obj,space):

return (n,space)

def rodFillBBoxWithRects(layer,fillBBox,width,length,spaceX,spaceY,gap="distribute",cvId=None):

return createObj(subs=rects,lpp=layer)

def createObj(dbox=None,subs=None,lpp=None):

return obj

def rodCreatePath(layer,width,pts,termIOType=None,termName=None,pin=None,subRect=None,name="",justification="center"):

return obj

def rodAddPoints(a,b):

return [a[0]+b[0],a[1] + b[1]]

def rodAddToY(a,b):

return [a[0],a[1] + b]

def rodAddToX(a,b):

return [a[0]+b,a[1]]

def makeVector(l,init=None):

return [init]*l

def rodCreatePolygon(name="",layer=None,fromObj=None,pts=None,pin=None,termName=None,termIOType=None,pinAccessDir=None):

return obj

def dbCreatePolygon(cv,layer,pts):

r = top.shapes(l1).insert(r)

def rodAssignHandleToParameter(**kwargs):

print("assignHandle: " + str(kwargs))

return None

def rodGetObj(i,cv=None):

return None

def rodPointX(l):

return l[0]

def rodPointY(l):

return l[1]

def snapToGrid(v,g):

ret = round(v/float(g))*g

return ret

#dbCreateLabel(cv 4 1:1 "myLabel" "centerLeft" "R0" "roman" 2)

def dbCreateLabel(cell,layer,origin,text,justification=None,orientation=None,font=None,height=1):

print("createLabel: " + str([flocals[arg] for arg in inspect.getargspec(dbCreateLabel).args]))

def dbCreateProp(cv,prop,t,val):

print("dbCreateProp: " + prop + ", " + str(val))

def dbOpenCellViewByType(lib,cell,purpose,t):

return ret

def dbOpenCellView(lib,cell,purpose,t,m):

return ret

def dbCreateRect(cell,layer,coord):

print("dbCreateRect: " + str(layer) + ", " + str(coord))

#assert(False)

return rodCreateRect(layer,coord[1][0] - coord[0][0],coord[1][1] - coord[0][1],coord[0])

def getRot(o):

assert(False)

def dbCreateParamInst(view, master, name, origin, orient, num=1, parm=None, phys=False):

return rodobj

def dbMoveFig(inst,cv,tr):

print("dbMoveFig: \"" + str(tr) )

#tr[0][1] *= -1

rodTranslate(inst,tr[0])

def dbCreateParamInstByMasterName(view, lib, cell, purpose, name, origin, orient, num=1, params=None, phys=False):

print("paraminst")

dbCreateParamInst(view,cell,name,origin,orient,num,params,phys)

return True

def dbCreateInstByMasterName(view, lib, cell, purpose, name, origin, orient="R0"):

print("createinst")

dbCreateParamInst(view,cell,name,origin,orient,1,None)

return True

def get_pname(s):

print("get_pname: " + str(s))

return s

env = {}

def envSetVal(domain,key,t,v):

env[key] = v

def concat(*args):

return ret

def rexMatchp(r,s):

return re.match(r,s)

def nullfunc(*args):

return None

def oddp(v):

return v%2==1

def evenp(v):

return v%2==0

def plusp(v):

return v>=0

def minus(a,b=None):

if b is None:

return -a

return a-b

def listp(v):

return isinstance(v,list)

def isCallable(l):

if not l.expr in skill.procedures:

return False

return not not skill.procedures[l.expr]

def cons(a,b):

return [a,b]

def xcons(a,b):

return cons(b,a)

def parseString(s,t=None):

if not t:

return s.split()

return s.split(t)

def strcat(*a):

return ret

def mmax(*l):

print("mmax")

print(*l)

return max(*l)

def mmin(*l):

print("mmin")

print(*l)

return min(*l)

def mapcar(l, v):

assert(False)

def nth(i,l): #TODO: not sure about this

return l[int(i)]

def getLast(l):

if not l:

return l

return l[-1]

def typep(v):

assert(False) #TODO:

def null(v):

return not v

def length(l):

return len(l)

#TODO: one of these is wrong

def append(a,b):

return a

def append1(a,b):

return a

def getq(a,b):

return a[b]

def snot(a):

return not a

def eval(v):

return v

def writeout(a):

write()

exit(0)

def ddGetObjReadPath(o):

return "."

def zerop(v):

return v == 0

def onep(v):

return v == 1

def close(f):

f.close()

def _gets(f):

return s

def substring(s,b,l):

return s[(b-1):][:l]

def setarray(a,b,c):

a[b] = c

def arrayref(a,b):

return a[b]

def findFunc(name):

return find

######################End skill function impls

def write():

layout.write("foo.gds")

layermap = {}

def run(layermap_file,s,r,l,p):