def toProteusTextFieldAction(self, label, fieldName, field, fldCat):
global classesToProcess
global classesEncoded
valStr = ''
if (fldCat == 'int' or fldCat == 'double'):
valStr = 'toString(' + fieldName + ')'
elif (fldCat == 'string' or fldCat == 'char'):
valStr = "\"'\" + " + fieldName + " + \"'\""
elif (fldCat == 'flag' or fldCat == 'bool'):
valStr = 'toString((' + fieldName + ')!=0)'
elif (fldCat == 'mode'):
valStr = 'toString(' + fieldName + ')' #fieldName+'Strings['+fieldName+'] '
elif (fldCat == 'struct'):
valStr = fieldName + '.asProteus(indent2)'
structTypeName = progSpec.getFieldType(field['typeSpec'])[0]
if not (structTypeName in classesEncoded):
# classesEncoded[structTypeName]=1
classesToProcess.append(structTypeName)
elif (fldCat == 'timeValue'):
valStr = 'toString(' + fieldName + ')'
if (fldCat == 'struct'):
S = 'S <- S + indent2 + ' + valStr + ' + "\\n"\n' #+label+'" + " = " + '+valStr+' + "\\n"\n'
else:
S = 'S <- S + indent2 + "' + label + '" + " = " +' + valStr + ' + "\\n"\n'
return S
def displayTextFieldAction(self, label, fieldName, field, fldCat):
global classesToProcess
global classesEncoded
valStr = ''
if (fldCat == 'int' or fldCat == 'double' or fldCat == 'BigInt'):
valStr = 'toString(' + fieldName + ')'
elif (fldCat == 'string' or fldCat == 'char'):
valStr = ' ' + fieldName + ' '
elif (fldCat == 'flag' or fldCat == 'bool'):
valStr = 'toString((' + fieldName + ')!=0)'
elif (fldCat == 'mode'):
valStr = fieldName + 'Strings[' + fieldName + '] ' #'toString('+fieldName+')' #fieldName+'Strings['+fieldName+'] '
elif (fldCat == 'struct'):
valStr = fieldName + '.makeString(indent+"| ")\n'
structTypeName = progSpec.getFieldType(field['typeSpec'])[0]
if not (structTypeName in classesEncoded):
classesToProcess.append(structTypeName)
if (fldCat == 'struct'):
S = " " + 'SRet_ <- SRet_ + indent + dispFieldAsText("' + label + '", 15) + "\\n"\n SRet_ <- SRet_ + ' + valStr + '+ "\\n"\n'
else:
ender = ''
starter = ''
if (fldCat == 'flag' or fldCat == 'bool'):
starter = 'if(' + fieldName + '){'
ender = '}'
elif (fldCat == 'int' or fldCat == 'double'):
starter = 'if(' + fieldName + '!=0){'
ender = '}'
S = " " + starter + 'SRet_ <- SRet_ + indent + dispFieldAsText("' + label + '", 15) + ' + valStr + ' + "\\n"\n' + ender
return S
def processField(self, fieldName, field, fldCat):
S = ""
itemName = '_' + fieldName + '_item'
if fldCat == 'func': return ''
typeSpec = field['typeSpec']
if progSpec.isAContainer(typeSpec):
if (progSpec.getDatastructID(typeSpec) == "list"):
innerFieldType = progSpec.getFieldType(typeSpec)
#print "ARRAYSPEC:",innerFieldType, field
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
itemName = '_' + fieldName + '_item'
calcdName = fieldName + '["+toString(' + itemName + '_key)+"]'
S += " withEach " + itemName + " in " + fieldName + "{\n"
S += " " + self.displayTextFieldAction(
calcdName, itemName, field, fldCatInner) + " }\n"
else:
cdlog(2, "Map not supported")
else:
S += self.displayTextFieldAction(fieldName, fieldName, field,
fldCat)
if progSpec.typeIsPointer(typeSpec):
T = " if(" + fieldName + ' == NULL){SRet_ <- SRet_ + ' + 'indent + dispFieldAsText("' + fieldName + '", 15)+"NULL\\n"}\n'
T += " else{\n " + S + " }\n"
S = T
self.textFuncBody += S
def toProteusTextFieldAction(self, label, fieldName, field, fldCat):
global classesToProcess
global classesEncoded
valStr = ''
if (fldCat == 'int' or fldCat == 'double'):
valStr = 'toString(' + fieldName + ')'
elif (fldCat == 'string' or fldCat == 'char'):
valStr = fieldName
elif (fldCat == 'flag' or fldCat == 'bool'):
valStr = 'dispBool((' + fieldName + ')!=0)'
elif (fldCat == 'mode'):
valStr = 'toString(' + fieldName + ')' #fieldName+'Strings['+fieldName+'] '
elif (fldCat == 'struct'):
valStr = fieldName + '.to_string(indent+"| ")\n'
structTypeName = progSpec.getFieldType(field['typeSpec'])[0]
if not (structTypeName in classesEncoded):
#print "TO ENDODE:", structTypeName
classesEncoded[structTypeName] = 1
classesToProcess.append(structTypeName)
if (fldCat == 'struct'):
S = 'S <- S + indent + dispFieldAsText("' + label + '", 15) + "\\n"\n ' + valStr + ' + "\\n"\n'
else:
S = 'S <- S + indent + dispFieldAsText("' + label + '", 15) + ' + valStr + ' + "\\n"\n'
return S
def writePositionalFetch(classes, tags, field):
fname=field['fieldName']
fieldType=str(progSpec.getFieldType(field))
S="""
me fetchResult: fetch_%s() <- {
if(%s_hasVal) {return (fetchOK)}
}
"""% (fname, fname)
return S
#print 'FIELD:', fname, field['owner'], '"'+fieldType+'"'
if(field['owner']=='const' and fieldType=='string'):
S+=' %s_hasLen <- true \n %s_span.len <- '% (fname, fname) + str(len(field['value']))
S+=" if(! %s_hasPos){pos <- pred.pos+pred.len}\n" % (fname)
S+=" if( %s_hasPos){\n" % (fname)
# Scoop Data
S+=' FieldTYpe("' + fieldType +'")\n'
if progSpec.isStruct(fieldType):
#print " Call stuct's fetch()"
pass
#elif fieldType=='':
# Set and propogate length
S+=" }\n"
S+=' }'
return S
def codeDogTypeToString(classes, tags, field):
#print "FIELD:", field
S = ''
fieldName = field['fieldName']
fieldType = progSpec.getFieldType(field)
fieldValue = field['value']
fieldOwner = field['owner']
if (fieldType == 'flag'):
if fieldValue != None and fieldValue != 0 and fieldValue != 'false':
S += 'flag: ' + fieldName + ' <- true\n'
else:
S += 'flag: ' + fieldName + '\n'
elif fieldType == 'mode':
if fieldValue != None:
S += 'mode [' + field[
'enumList'] + ']: ' + fieldName + ' <- ' + fieldValue + '\n'
else:
S += 'mode [' + field['enumList'] + ']: ' + fieldName + '\n'
elif fieldOwner == 'const':
#print 'const ', fieldType, ': ', fieldName, ' <- ',fieldValue
#S+='const '+fieldType+': ' + fieldName + ' <- '+fieldValue+'\n'
pass
elif fieldOwner == 'const':
print("Finish This")
return S
def writeNonTermParseRule(classes, tags, modelName, fields, SeqOrAlt, nameSuffix, logLvl):
global nextParseNameID
nameIn=modelName+nameSuffix
# Allocate or fetch a rule identifier for each '>' field.
partIndexes=[]
for field in fields:
fname=field['fieldName']
if fname==None: fname=''
else: fname='_'+fname
typeSpec =field['typeSpec']
if(field['isNext']==True): # means in the parse there was a '>' symbol, a sequence seperator
firstItm=progSpec.getFieldType(field['typeSpec'])[0]
if firstItm=='[' or firstItm=='{': # Handle an ALT or SEQ sub structure
cdlog(logLvl, "NonTERM: {} = {}".format(fname, firstItm))
nextParseNameID+=1
if firstItm=='[':
innerSeqOrAlt='parseALT'
newNameSuffix = nameSuffix+fname+'_ALT'+str(nextParseNameID)
else:
innerSeqOrAlt='parseSEQ'
newNameSuffix = nameSuffix+fname+'_SEQ'+str(nextParseNameID)
innerFields=field['innerDefs']
ruleIdxStr = writeNonTermParseRule(classes, tags, modelName, innerFields, innerSeqOrAlt, newNameSuffix, logLvl+1)
field['parseRule']=ruleIdxStr
if progSpec.isAContainer(typeSpec):
# anything with [] is a container: lists and optionals
global rules
containerSpec = progSpec.getContainerSpec(typeSpec)
idxType=''
if 'indexType' in containerSpec:
idxType=containerSpec['indexType']
if(isinstance(containerSpec['datastructID'], str)):
datastructID = containerSpec['datastructID']
else: # it's a parseResult
datastructID = containerSpec['datastructID'][0]
if idxType[0:4]=='uint': pass
if(datastructID=='list'):
ruleIdxStr=appendRule(ruleIdxStr+'_REP', "nonterm", "parseREP", [ruleIdxStr, 0, 0])
elif datastructID=='opt':
ruleIdxStr=appendRule(ruleIdxStr+'_OPT', "nonterm", "parseREP", [ruleIdxStr, 0, 1])
else:
ruleIdxStr = fetchOrWriteTerminalParseRule(modelName, field, logLvl)
partIndexes.append(ruleIdxStr)
else: pass; # These fields probably have corresponding cofactuals
nameOut=appendRule(nameIn, "nonterm", SeqOrAlt, partIndexes)
return nameOut
def processField(self, fieldName, field, fldCat):
S = ""
if fldCat == 'func': return ''
typeSpec = field['typeSpec']
if progSpec.isAContainer(typeSpec):
innerFieldType = progSpec.getFieldType(typeSpec)
#print "ARRAYSPEC:",innerFieldType, field
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
calcdName = fieldName + '["+toString(_item_key)+"]'
S += " withEach _item in " + fieldName + "{\n"
S += " " + self.toProteusTextFieldAction(
calcdName, '_item', field, fldCatInner) + " }\n"
else:
S += " " + self.toProteusTextFieldAction(
fieldName, fieldName, field, fldCat)
if progSpec.typeIsPointer(typeSpec):
T = " if(" + fieldName + ' == NULL){S <- S + ' + 'indent, dispFieldAsText("' + fieldName + '", 15)+"NULL\\n")}\n'
T += " else{\n " + S + " }\n"
S = T
self.textFuncBody += S
def getDashDeclAndUpdateCode(self, owner, fieldLabel, fieldRef, fieldName,
field, skipFlags, indent):
global classesToProcess
global classesEncoded
itemName = '_' + fieldName + '_item'
dashKeyName = '_' + fieldName + '_dash_key'
OldElementsName = '_' + fieldName + 'OldElements'
[
structText, updateFuncText, setPosFuncText, drawFuncText,
handleClicksFuncText
] = ['', '', '', '', '']
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
if fldCat == 'func': return ['', '', '', '', '']
if progSpec.typeIsPointer(
typeSpec) and skipFlags != 'skipPtr': # Header for a POINTER
fieldName += 'Ptr'
if fieldRef == 'data.itmItr':
innerUpdateFuncStr = '"ItmItr"' # TODO: unhard code this reference to itmItr
else:
innerUpdateFuncStr = fieldRef + '.mySymbol(' + fieldRef + ')'
updateFuncText += ' ' + fieldName + '.dashParent <- self\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ' + innerUpdateFuncStr + ', isNull(' + innerUpdateFuncStr + '))\n'
structText += " " + owner + " ptrToItem: " + fieldName + "\n"
elif progSpec.isAContainer(
typeSpec
) and skipFlags != 'skipLists': # Header and items for LIST
dispStructTypeName = "display_" + progSpec.getFieldType(
field['typeSpec'])[0]
innerUpdateFuncStr = '"Size:"+toString(data.' + fieldName + '.size())'
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += ' ' + 'our dash[our list]: ' + OldElementsName + ' <- ' + fieldName + '.elements\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ' + innerUpdateFuncStr + ', isNull(' + innerUpdateFuncStr + '), true)\n'
## Now push each item
innerFieldType = progSpec.getFieldType(typeSpec)
containerTypeSpec = progSpec.getContainerSpec(typeSpec)
if len(containerTypeSpec) > 3 and (
containerTypeSpec[1] == 'map' or containerTypeSpec[1]
== 'multimap') and containerTypeSpec[2][0] == 'string':
itemKeyCode = itemName + '_key'
else:
itemKeyCode = 'toString(' + itemName + '_key)'
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
if fieldRef == 'data.itmItr' or fieldRef == 'data.items':
newFieldRef = itemName + '' # TODO: unhard code this reference to itmItr
else:
newFieldRef = 'data.' + fieldName + '[' + itemName + '_key]'
newFieldLabel = '"["+' + itemKeyCode + '+"] "+ ' + itemName + '.mySymbol(' + itemName + ')'
updateFuncText += '\n ' + 'me int64: ' + dashKeyName + ' <- 0'
updateFuncText += "\n withEach " + itemName + " in data." + fieldName + "{\n"
[
innerStructText, innerUpdateFuncText, innerDrawFuncText,
innerSetPosFuncText, innerHandleClicksFuncText
] = self.getDashDeclAndUpdateCode('our', newFieldLabel,
newFieldRef, 'newItem', field,
'skipLists', ' ')
updateFuncText += ' ' + innerStructText
updateFuncText += ' me bool: _elementExists <- false\n'
updateFuncText += ' ' + 'if(' + OldElementsName + '!=NULL){\n'
updateFuncText += ' ' + 'withEach _ElItem in ' + OldElementsName + '{\n'
updateFuncText += ' ' + 'if(asClass(' + dispStructTypeName + ', _ElItem).data === ' + itemName + '){\n'
updateFuncText += ' ' + '_elementExists <- true; break();\n'
updateFuncText += ' ' + '}}}\n'
updateFuncText += ' ' + 'if(!_elementExists){\n'
updateFuncText += ' Allocate(newItem)\n'
updateFuncText += ' newItem.dashParent <- self\n'
updateFuncText += ' ' + 'addDependent(' + itemName + '.mySymbol(' + itemName + '), newItem)'
updateFuncText += '\n } else {\n newItem <- asClass(' + dispStructTypeName + ', ' + OldElementsName + '[' + dashKeyName + '])\n ' + dashKeyName + ' <- ' + dashKeyName + ' + 1'
updateFuncText += '\n }'
updateFuncText += '\n ' + innerUpdateFuncText
updateFuncText += ' ' + fieldName + '.updatePush(newItem)'
updateFuncText += '\n }\n'
structText += ' ' + owner + ' listOfItems: ' + fieldName + '\n'
elif (fldCat == 'struct'): # Header for a STRUCT
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ">", ' + fieldRef + ')\n'
structTypeName = progSpec.getNewContainerFirstElementTypeTempFunc(
typeSpec)
if structTypeName == None:
structTypeName = progSpec.getFieldType(typeSpec)[0]
structText += " " + owner + " display_" + structTypeName + ': ' + fieldName + "\n"
# Add new classname to a list so it can be encoded.
if not (structTypeName in classesToProcess):
classesToProcess.append(structTypeName)
else: # Display field for a BASIC TYPES
valStr = ''
if (fldCat == 'int' or fldCat == 'double'):
valStr = 'toString(data.' + fieldName + ')'
elif (fldCat == 'string' or fldCat == 'char'):
valStr = '"\'"+' + 'data.' + fieldName + '+"\'"'
elif (fldCat == 'flag' or fldCat == 'bool'):
valStr = 'toString((data.' + fieldName + ')!=0)'
elif (fldCat == 'mode'):
valStr = fieldRef + 'Strings[data.' + fieldName + '] '
updateFuncText = " " + fieldName + '.update(100, 180, ' + fieldLabel + ', ' + valStr + ', isNull(' + valStr + '))\n'
structText += " " + owner + " dataField: " + fieldName + "\n"
drawFuncText = " " + fieldName + '.draw(cr)\n'
setPosFuncText += ''' if(!<fieldName>.isNullLike or displayMode==fullDisplay){
<fieldName>.setPos(x,y,extC)
extC <- <fieldName>.extC
y <- y + <fieldName>.height
extX <- max(extX, <fieldName>.extX)
extY <- max(extY, <fieldName>.extY)
width<- max(width, <fieldName>.width)
<fieldName>.isHidden<-false
} else {<fieldName>.isHidden<-true}
'''.replace('<fieldName>', fieldName)
# updateFuncText+=' if(crntWidth<'+fieldName+'.width){crntWidth <- '+fieldName+'.width}'
handleClicksFuncText = ' ' + fieldName + '.primaryClick(event)'
return [
structText, updateFuncText, drawFuncText, setPosFuncText,
handleClicksFuncText
]
def addOrAmendClasses(self, classes, className, modelRef):
self.setPosFuncTextAcc += '\n y <- y+5' + '\n height <- y-posY' + '\n me int:depX <- posX+width+40\n'
countOfRefs = 0
for field in modelRef['fields']:
typeSpec = field['typeSpec']
typeName = progSpec.getFieldType(field['typeSpec'])[0]
fldCat = progSpec.fieldsTypeCategory(typeSpec)
if fldCat == 'func': continue
if progSpec.typeIsPointer(typeSpec): # Draw dereferenced POINTER
fieldName = field['fieldName']
dispStructTypeName = "display_" + typeName
declSymbolStr = ' '
if (countOfRefs == 0): declSymbolStr += 'me string: '
countOfRefs += 1
[
structText, updateFuncText, drawFuncText, setPosFuncText,
handleClicksFuncText
] = self.getDashDeclAndUpdateCode('their',
'"' + fieldName + '"',
'data.' + fieldName,
fieldName, field, 'skipPtr',
' ')
self.structTextAcc += structText
tempFuncText = updateFuncText
updateFuncText = declSymbolStr + 'mySymbol <- data.' + fieldName + '.mySymbol(data.' + fieldName + ')\n'
updateFuncText += (
' if(data.' + fieldName + ' != NULL){\n' + ' ' +
fieldName + ' <- asClass(' + dispStructTypeName +
', dependentIsRegistered(mySymbol))\n'
' if(!' + fieldName + '){'
'\n Allocate(' + fieldName + ')' +
'\n ' + fieldName + '.dashParent <- self' +
'\n addDependent(mySymbol, ' + fieldName + ')' +
'\n' + tempFuncText + '\n }\n } else {' +
fieldName + ' <- NULL}\n')
self.updateFuncTextPart2Acc += updateFuncText
self.setPosFuncTextAcc += '''
if(<fieldName> != NULL and !<fieldName>Ptr.refHidden){
if(!<fieldName>.posIsSet){
<fieldName>.setPos(depX, extC, extC)
extC <- <fieldName>.extY + 40
extX <- max(extX, <fieldName>.extX)
extY <- max(extY, <fieldName>.extY)
}
addRelation("arrow", <fieldName>Ptr, <fieldName>)
}
'''.replace('<fieldName>', fieldName)
self.handleClicksFuncTxtAcc2 += ' if(' + fieldName + ' != NULL and !' + fieldName + 'Ptr.refHidden){\n' + fieldName + '.isHidden<-false\n }\n'
Code = '''
struct display_''' + className + ": inherits=dash" + '''{
me bool: isChanged
me dataField: header
me mode[headerOnly, fullDisplay, noZeros]: displayMode
their ''' + className + ''': data
''' + self.structTextAcc + '''
void: update(me string: _label, me string: textValue, their ''' + className + ''': _Data) <- {
title <- "''' + className + ''':" + _label
isChanged <- !(data === _Data)
data <- _Data
if(data==NULL){
header.update(100, 180, _label, "NULL", false)
return()
}
header.update(100, 180, _label, textValue, false)
if(isChanged){displayMode<-headerOnly}
''' + self.updateFuncTextAcc + '''
''' + self.updateFuncTextPart2Acc + '''
}
void: setPos(me int:x, me int:y, me int: extCursor) <- {
posIsSet <- true
posX <- x;
posY <- y;
extC <- extCursor
isHidden<-false
header.setPos(x,y,extC)
y <- y+header.height
width <- header.width
height <- y-posY
extX <- header.extX
extY <- max(y, extC)
if(displayMode!=headerOnly){
x <- x+10 // Indent fields in a struct
''' + self.setPosFuncTextAcc + '''
width <- width+10
}
}
me bool: primaryClick(their GUI_ButtonEvent: event) <- {
if(isHidden){return(false)}
me GUI_Scalar: eventX <- event.x
me GUI_Scalar: eventY <- event.y
if( header.isTouching(eventX, eventY)){
if(displayMode==headerOnly){displayMode <- noZeros}
else if(displayMode==noZeros){displayMode <- fullDisplay}
else if(displayMode==fullDisplay){displayMode <- headerOnly}
} else {
''' + self.handleClicksFuncTextAcc + '''
}
''' + self.handleClicksFuncTxtAcc2 + '''
return(true)
}
void: draw(their GUI_ctxt: cr) <- {
header.isHidden <- false
me cdColor: hedrColor <- styler.frGndColor
cr.setColor(hedrColor)
header.draw(cr)
cr.strokeNow()
hedrColor <- styler.frGndColor
cr.setColor(hedrColor)
if(displayMode!=headerOnly){
''' + self.drawFuncTextAcc + '''
me cdColor: rectColor <- styler.color(data.mySymbol(data), styler.frGndColor)
cr.setColor(rectColor)
cr.rectangle(posX, posY, width, height)
cr.strokeNow()
rectColor <- styler.frGndColor
cr.setColor(rectColor)
''' + self.drawFuncTextPart2Acc + '''
}
}
}\n'''
#if className == 'pureInfon': print Code
codeDogParser.AddToObjectFromText(classes[0], classes[1], Code,
'display_' + className)
def Write_fieldExtracter(classes, ToStructName, field, memObjFields, VarTagBase, VarName, advancePtr, indent, level, logLvl):
debugTmp=False # Erase this line
VarTag=VarTagBase+str(level)
################### G a t h e r N e e d e d I n f o r m a t i o n
global globalFieldCount
global globalTempVarIdx
S=''
fieldName = field['fieldName']
fieldIsNext= field['isNext']
fieldValue = field['value']
typeSpec = field['typeSpec']
fieldType = progSpec.getFieldType(typeSpec)
fieldOwner =typeSpec['owner']
fromIsEmbeddedAlt = (not isinstance(fieldType, str) and fieldType[0]=='[')
fromIsEmbeddedSeq = (not isinstance(fieldType, str) and fieldType[0]=='{')
fromIsEmbedded = fromIsEmbeddedAlt or fromIsEmbeddedSeq
if(fieldIsNext!=True): return '' # This field isn't in the parse stream.
[memObj, memVersionName]=fetchMemVersion(classes, ToStructName)
toField = progSpec.fetchFieldByName(memObjFields, fieldName)
if(toField==None):
#print " TOFIELD == None", fieldName
# Even tho there is no LVAL, we need to move the cursor. Also, there could be a co-factual.
toFieldType = progSpec.TypeSpecsMinimumBaseType(classes, typeSpec)
toTypeSpec=typeSpec
toFieldOwner="me"
else:
toTypeSpec = toField['typeSpec']
toFieldType = progSpec.getFieldType(toTypeSpec)
toFieldOwner = progSpec.getInnerContainerOwner(toTypeSpec)
if debugTmp:
print(' toFieldType:', toFieldType)
LHS_IsPointer=progSpec.typeIsPointer(toTypeSpec)
# print " CONVERTING:", fieldName, str(toFieldType)[:100]+'... ', str(typeSpec)[:100]+'... '
# print " TOFieldTYPE1:", str(toField)[:100]
# print " TOFieldTYPE :", toFieldOwner, toFieldType
# print " fieldValue:",ToStructName, fieldType, fieldValue
cdlog(logLvl, "FIELD {}: '{}'".format(fieldName, str(fieldValue)))
fields=[]
fromIsStruct=progSpec.isStruct(fieldType)
toIsStruct=progSpec.isStruct(toFieldType)
ToIsEmbedded = toIsStruct and (toFieldType[0]=='[' or toFieldType[0]=='{')
[fromIsALT, fields] = progSpec.isAltStruct(classes, fieldType)
fromIsOPT =False
fromIsList=False
toIsList =False
if progSpec.isAContainer(typeSpec):
datastructID = progSpec.getDatastructID(typeSpec)
if datastructID=='opt': fromIsOPT=True;
else: fromIsList=True
if progSpec.isAContainer(toTypeSpec):
if datastructID != 'opt': toIsList=True
if debugTmp:
print(' fromIsOPT:', fromIsOPT)
print(' fromIsList:', fromIsList)
print(' toIsList:', toIsList)
print(' fromIsStruct:', fromIsStruct)
print(' toIsStruct:', toIsStruct)
print(' fieldType:', fieldType)
print(' ToIsEmbedded:', ToIsEmbedded)
print(' ToStructName:', ToStructName)
print(' memVersionName:', memVersionName, "\n")
################### W r i t e L V A L R e f e r e n c e
finalCodeStr=''
CodeLVAR_Alloc=''
CODE_LVAR_v2=''
if VarName=='' or VarName=='memStruct': # Default to the target argument name
#if VarName=='': print " VARNAME was ''; FIELDNAME:", fieldName
VarName='memStruct'
if(fieldName==None): # Field hasn't a name so in memory it's a cofactual or this is a parser marker.
globalFieldCount+=1
# We need two versions in case this is set in a function instead of assignment
CODE_LVAR_v2 = 'S'+str(globalFieldCount)
CodeLVAR_Alloc=' me string: '+CODE_LVAR_v2
CODE_LVAR = CodeLVAR_Alloc
if debugTmp: print(' CODE_LVARS:', CODE_LVAR)
else:
CODE_LVAR = VarName+'.'+fieldName
if fieldName=='inf': CODE_LVAR = VarName
CODE_LVAR_v2 = CODE_LVAR
else:
CODE_LVAR = VarName
CODE_LVAR_v2 = CODE_LVAR
################### W r i t e R V A L C o d e
CODE_RVAL=''
objName=''
humanIDType= VarTag+' ('+str(fieldName)+' / '+str(fieldValue) + ' / '+str(fieldType)[:40] +')'
humanIDType=humanIDType.replace('"', "'")
#print humanIDType
if advancePtr:
S+=indent+VarTag+' <- getNextStateRec('+VarTag+')\n'
# UNCOMMENT FOR DEGUG: S+=' docPos('+str(level)+', '+VarTag+', "Get Next in SEQ for: '+humanIDType+'")\n'
if fieldOwner=='const'and (toField == None):
#print'CONSTFIELDVALUE("'+fieldValue+'")\n'
finalCodeStr += indent + 'tmpStr'+' <- makeStr('+VarTag+"<LVL_SUFFIX>"+'.child)\n'
else:
if toIsStruct:
if debugTmp: print(' toFieldType:', toFieldType)
if not ToIsEmbedded:
objName=toFieldType[0]
if progSpec.typeIsInteger(objName):
strFieldType = fieldType[0]
if(strFieldType == "BigInt"):
CODE_RVAL='makeStr('+VarTag+'.child'+')'
elif(strFieldType == "HexNum"):
CODE_RVAL='makeHexInt('+VarTag+'.child'+')'
elif(strFieldType == "BinNum"):
CODE_RVAL='makeBinInt('+VarTag+'.child'+')'
else:
CODE_RVAL='makeStr('+VarTag+'.child'+')'
toIsStruct=False; # false because it is really a base type.
elif (objName=='ws' or objName=='wsc' or objName=='quotedStr1' or objName=='quotedStr2' or objName=='CID' or objName=='UniID'
or objName=='printables' or objName=='toEOL' or objName=='alphaNumSeq'):
CODE_RVAL='makeStr('+VarTag+'.child'+')'
toIsStruct=False; # false because it is really a base type.
else:
#print "toObjName:", objName, memVersionName, fieldName
[toMemObj, toMemVersionName]=fetchMemVersion(classes, objName)
if toMemVersionName==None:
# make alternate finalCodeStr. Also, write the extractor that extracts toStruct fields to memVersion of this
childStr = ".child"
if fromIsOPT:
childStr += ".next"
finalCodeStr=(indent + CodeLVAR_Alloc + '\n' +indent+' '+getFunctionName(fieldType[0], memVersionName)+'('+VarTag+"<LVL_SUFFIX>"+childStr+', memStruct)\n')
objSpec = progSpec.findSpecOf(classes[0], objName, 'string')
ToFields=objSpec['fields']
FromStructName=objName
Write_Extracter(classes, ToStructName, FromStructName, logLvl+1)
else:
fromFieldTypeCID = fieldType[0].replace('::', '_')
toFieldTypeCID = toMemVersionName.replace('::', '_')
#print "FUNC:", getFunctionName(fromFieldTypeCID, toFieldTypeCID)
if fromFieldTypeCID != toFieldTypeCID:
Write_Extracter(classes, toFieldTypeCID, fromFieldTypeCID, logLvl+1)
finalCodeStr=indent + CodeLVAR_Alloc + '\n' +indent+' '+getFunctionName(fromFieldTypeCID, toFieldTypeCID)+'('+VarTag+"<LVL_SUFFIX>"+'.child, '+CODE_LVAR_v2+')\n'
else: pass
else:
CODE_RVAL = CodeRValExpr(toFieldType, VarTag, "")
#print "CODE_RVAL:", CODE_RVAL
################### H a n d l e o p t i o n a l a n d r e p e t i t i o n a n d a s s i g n m e n t c a s e s
gatherFieldCode=''
if fromIsList and toIsList:
CODE_RVAL='tmpVar'
globalFieldCount +=1
childRecName='SRec' + str(globalFieldCount)
gatherFieldCode+='\n'+indent+'\nour stateRec: '+childRecName+' <- '+VarTag+'.child.next'
gatherFieldCode+='\n'+indent+'while('+childRecName+'){\n'
if fromIsALT:
# print "ALT-#1"
gatherFieldCode+=Write_ALT_Extracter(classes, fieldType[0], fields, childRecName, '', 'tmpVar', indent+' ', level)
elif fromIsStruct and toIsStruct:
gatherFieldCode+='\n'+indent+toFieldOwner+' '+progSpec.baseStructName(toFieldType[0])+': tmpVar'
if toFieldOwner!='me':
gatherFieldCode+='\n'+indent+'Allocate('+CODE_RVAL+')'
#print "##### FUNCT:", getFunctionName(fieldType[0], fieldType[0])
gatherFieldCode+='\n'+indent+getFunctionName(fieldType[0], toFieldType[0])+'('+childRecName+'.child, tmpVar)\n'
else:
CODE_RVAL = CodeRValExpr(toFieldType, childRecName, ".next")
# Now code to push the chosen alternative into the data field# This is a LIST, not an OPT:
gatherFieldCode+='\n'+indent+CODE_LVAR+'.pushLast('+CODE_RVAL+')'
gatherFieldCode+=indent+' '+childRecName+' <- getNextStateRec('+childRecName+')\n'
# UNCOMMENT FOR DEGUG: S+= ' docPos('+str(level)+', '+VarTag+', "Get Next in LIST for: '+humanIDType+'")\n'
gatherFieldCode+='\n'+indent+'}\n'
if(fromIsOPT):
print("Handle when the optional item is a list.");
exit(2)
else:
if toIsList: print("Error: parsing a non-list to a list is not supported.\n"); exit(1);
levelSuffix=''
assignerCode=''
oldIndent=indent
if (fromIsOPT):
setTrueCode=''
assignerCode+='\n'+indent+'if('+VarTag+'.child.next' +' == NULL){'
if toFieldOwner=='me':
if debugTmp: print(' toFieldOwner:', toFieldOwner)
## if fieldName==None and a model of fromFieldType has no cooresponding model But we are in EXTRACT_ mode:
## Make a special form of Extract_fromFieldType_to_ToFieldType()
## Call that function instead of the one in Code_LVAR
# First, create a new flag field
if fieldName==None:
fieldName="TEMP"+str(globalTempVarIdx)
globalTempVarIdx += globalTempVarIdx
newFieldsName=fieldName #'has_'+fieldName
fieldDef=progSpec.packField(ToStructName, False, 'me', 'flag', None, None, newFieldsName, None, None, None, False)
progSpec.addField(classes[0], memVersionName, 'struct', fieldDef)
# Second, generate the code to set the flag
assignerCode+='\n'+indent+' '+VarName+'.'+newFieldsName+' <- false'
setTrueCode += VarName+'.'+newFieldsName+' <- true'
elif LHS_IsPointer: # If owner is my, our or their
assignerCode+='\n'+indent+' '+CODE_LVAR+' <- NULL'
else:
print("ERROR: OPTional fields must not be '"+toFieldOwner+"'.\n")
exit(1)
assignerCode+='\n'+indent+'} else {\n'
levelSuffix='.child.next'
indent+=' '
assignerCode+=indent+setTrueCode+'\n'
if fromIsALT or fromIsEmbeddedAlt:
if(fromIsEmbeddedAlt):
# print "ALT-#2"
assignerCode+=Write_ALT_Extracter(classes, ToStructName, field['innerDefs'], VarTagBase, levelSuffix, VarName, indent+' ', level+1, logLvl+1)
else:
# print "ALT-#3"
assignerCode+=Write_ALT_Extracter(classes, fieldType[0], fields, VarTagBase, levelSuffix, VarName+'X', indent+' ', level, logLvl+1)
assignerCode+=indent+CODE_LVAR+' <- '+(VarName+'X')+"\n"
elif fromIsEmbeddedSeq:
globalFieldCount +=1
childRecNameBase='childSRec' + str(globalFieldCount)
childRecName=childRecNameBase+str(level)
assignerCode+='\n'+indent+'our stateRec: '+childRecName+' <- '+VarTag+levelSuffix+'.child\n'
for innerField in field['innerDefs']:
assignerCode+=Write_fieldExtracter(classes, ToStructName, innerField, memObjFields, childRecNameBase, '', True, ' ', level, logLvl+1)
elif fromIsStruct and toIsStruct:
assignerCode+=finalCodeStr.replace("<LVL_SUFFIX>", levelSuffix);
if debugTmp: print(' assignerCode:', assignerCode)
else:
# if toFieldOwner == 'const': print "Error: Attempt to extract a parse to const field.\n"; exit(1);
if CODE_RVAL!="":
if LHS_IsPointer:
assignerCode+=' '+CODE_LVAR+' <deep- '+CODE_RVAL+"\n"
else: assignerCode+=' '+CODE_LVAR+' <- '+CODE_RVAL+"\n"
elif finalCodeStr!="": assignerCode+=finalCodeStr.replace("<LVL_SUFFIX>", levelSuffix);
if (fromIsOPT):
indent=oldIndent
assignerCode += indent+'}\n'
#print '######################\n'+assignerCode, memVersionName, '\n'
# exit(2)
gatherFieldCode = assignerCode
#print ("##########################\n",S,"\n#####################################\n")
if LHS_IsPointer: # LVAL is a pointer and should be allocated or cleared.
S+= indent + 'AllocateOrClear(' +CODE_LVAR +')\n'
S+=gatherFieldCode
#print "ASSIGN_CODE", S
# if debugTmp: exit(2)
return S
def fetchOrWriteTerminalParseRule(modelName, field, logLvl):
global nextParseNameID
#print "FIELD_IN:", modelName, field
fieldName='N/A'
fieldValue=''
if 'value' in field: fieldValue =field['value']
typeSpec = field['typeSpec']
fieldType = progSpec.getFieldType(typeSpec)
fieldOwner = typeSpec['owner']
if 'fieldName' in field: fieldName =field['fieldName']
cdlog(logLvl, "WRITING PARSE RULE for: {}.{}".format(modelName, fieldName))
#print "WRITE PARSE RULE:", modelName, fieldName
nameIn=None
nameOut=None
if fieldOwner=='const':
if fieldType=='string':
if fieldValue in definedRules: nameOut=definedRules[fieldValue]
else: nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:4]=='uint': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:3]=='int': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:6]=='double': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:4]=='char': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
elif fieldType[0:4]=='bool': nameOut=appendRule(nameIn, "term", "parseSEQ", fieldValue)
else:
print("Unusable const type in fetchOrWriteTerminalParseRule():", fieldType); exit(2);
elif fieldOwner=='me' or fieldOwner=='their' or fieldOwner=='our':
if fieldType=='string': nameOut='quotedStr'
elif fieldType[0:4]=='uint': nameOut='uintSeq'
elif fieldType[0:3]=='int': nameOut='intSeq'
elif fieldType[0:6]=='double': nameOut='RdxSeq'
elif fieldType[0:4]=='char': nameOut=appendRule(nameIn, "term", "parseSEQ", None)
elif fieldType[0:4]=='bool': nameOut=appendRule(nameIn, "term", "parseSEQ", None)
elif progSpec.isStruct(fieldType):
objName=fieldType[0]
if (objName=='ws' or objName=='wsc' or objName=='quotedStr' or objName=='quotedStr1' or objName=='quotedStr2'
or objName=='CID' or objName=='UniID' or objName=='printables' or objName=='toEOL' or objName=='alphaNumSeq'
or progSpec.typeIsInteger(objName)):
nameOut=objName
else:
if objName=='[' or objName=='{': # This is an ALT or SEQ sub structure
print("ERROR: These should be handled in writeNonTermParseRule().\n")
exit(1)
else: nameOut=objName+'_str'
elif progSpec.isAlt(fieldType):
pass
elif progSpec.isCofactual(fieldType):
pass
else:
print("Unusable type in fetchOrWriteTerminalParseRule():", fieldType); exit(2);
else: print("Pointer types not yet handled in fetchOrWriteTerminalParseRule():", fieldType); exit(2);
if progSpec.isAContainer(typeSpec):
global rules
containerSpec = progSpec.getContainerSpec(typeSpec)
idxType=''
if 'indexType' in containerSpec:
idxType=containerSpec['indexType']
if(isinstance(containerSpec['datastructID'], str)):
datastructID = containerSpec['datastructID']
else: # it's a parseResult
datastructID = containerSpec['datastructID'][0]
if idxType[0:4]=='uint': pass
if(datastructID=='list'):
nameOut=appendRule(nameOut+'_REP', "nonterm", "parseREP", [nameOut, 0, 0])
elif datastructID=='opt':
nameOut=appendRule(nameOut+'_OPT', "nonterm", "parseREP", [nameOut, 0, 1])
#print("NAMEOUT:", nameOut)
field['parseRule']=nameOut
return nameOut
def getDashDeclAndUpdateCode(self, owner, fieldLabel, fieldRef, fieldName,
field, skipFlags, indent):
global classesToProcess
global classesEncoded
[
structText, updateFuncText, setPosFuncText, drawFuncText,
handleClicksFuncText
] = ['', '', '', '', '']
typeSpec = field['typeSpec']
fldCat = progSpec.fieldsTypeCategory(typeSpec)
if fldCat == 'func': return ['', '', '', '', '']
if progSpec.typeIsPointer(
typeSpec) and skipFlags != 'skipPtr': # Header for a POINTER
fieldName += 'Ptr'
if fieldRef == 'data.itmItr':
innerUpdateFuncStr = '"ItmItr"' # TODO: unhard code this reference to itmItr
else:
innerUpdateFuncStr = fieldRef + '.mySymbol(' + fieldRef + ')'
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ' + innerUpdateFuncStr + ', isNull(' + innerUpdateFuncStr + '))\n'
structText += " " + owner + " ptrToItem: " + fieldName + "\n"
elif progSpec.isAContainer(
typeSpec
) and skipFlags != 'skipLists': # Header and items for LIST
dispStructTypeName = "display_" + progSpec.getFieldType(
field['typeSpec'])[0]
innerUpdateFuncStr = '"Size:"+toString(data.' + fieldName + '.size())'
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += " " + "our dash[our list]: oldElements <- " + fieldName + ".elements\n"
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ' + innerUpdateFuncStr + ', isNull(' + innerUpdateFuncStr + '), true)\n'
## Now push each item
innerFieldType = progSpec.getFieldType(typeSpec)
#print "ARRAYSPEC:",innerFieldType, field
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
if fieldRef == 'data.itmItr' or fieldRef == 'data.items':
newFieldRef = '_item' # TODO: unhard code this reference to itmItr
else:
newFieldRef = 'data.' + fieldName + '[_item_key]'
newFieldLabel = '"["+toString(_item_key)+"] "+ _item.mySymbol(_item)'
updateFuncText += "\n " + "me int64: dash_key <- 0"
updateFuncText += "\n withEach _item in data." + fieldName + "{\n"
[
innerStructText, innerUpdateFuncText, innerDrawFuncText,
innerSetPosFuncText, innerHandleClicksFuncText
] = self.getDashDeclAndUpdateCode('our', newFieldLabel,
newFieldRef, 'newItem', field,
'skipLists', ' ')
updateFuncText += " " + innerStructText
updateFuncText += " " + "if(oldElements==NULL or (oldElements!=NULL and !(asClass(" + dispStructTypeName + ", oldElements[dash_key]).data === _item))){\n"
updateFuncText += ' Allocate(newItem)\n'
updateFuncText += ' newItem.dashParent <- self\n'
updateFuncText += ' ' + 'addDependent(_item.mySymbol(_item), newItem)'
updateFuncText += '\n } else {\n newItem <- asClass(' + dispStructTypeName + ', oldElements[dash_key])\n dash_key <- dash_key + 1'
updateFuncText += '\n }'
updateFuncText += '\n ' + innerUpdateFuncText
updateFuncText += ' ' + fieldName + '.updatePush(newItem)'
updateFuncText += '\n }\n'
structText += " " + owner + " listOfItems: " + fieldName + "\n"
elif (fldCat == 'struct'): # Header for a STRUCT
updateFuncText += " " + fieldName + '.dashParent <- self\n'
updateFuncText += " " + fieldName + '.update(' + fieldLabel + ', ">", ' + fieldRef + ')\n'
if 'fieldType' in typeSpec and not (isinstance(
typeSpec['fieldType'], basestring
)) and typeSpec['fieldType'][0] == 'DblLinkedList':
structTypeName = 'infon'
else:
structTypeName = progSpec.getFieldType(typeSpec)[0]
structText += " " + owner + " display_" + structTypeName + ': ' + fieldName + "\n"
# Add new classname to a list so it can be encoded.
if not (structTypeName in classesToProcess):
classesToProcess.append(structTypeName)
else: # Display field for a BASIC TYPES
valStr = ''
if (fldCat == 'int' or fldCat == 'double'):
valStr = 'toString(data.' + fieldName + ')'
elif (fldCat == 'string' or fldCat == 'char'):
valStr = '"\'"+' + 'data.' + fieldName + '+"\'"'
elif (fldCat == 'flag' or fldCat == 'bool'):
valStr = 'dispBool((data.' + fieldName + ')!=0)'
elif (fldCat == 'mode'):
valStr = fieldRef + 'Strings[data.' + fieldName + '] '
updateFuncText = " " + fieldName + '.update(100, 180, ' + fieldLabel + ', ' + valStr + ', isNull(' + valStr + '))\n'
structText += " " + owner + " dataField: " + fieldName + "\n"
drawFuncText = " " + fieldName + '.draw(cr)\n'
setPosFuncText += ''' if(!<fieldName>.isNullLike or displayMode==fullDisplay){
<fieldName>.setPos(x,y,extC)
extC <- <fieldName>.extC
y <- y + <fieldName>.height
extX <- max(extX, <fieldName>.extX)
extY <- max(extY, <fieldName>.extY)
width<- max(width, <fieldName>.width)
<fieldName>.isHidden<-false
} else {<fieldName>.isHidden<-true}
'''.replace('<fieldName>', fieldName)
# updateFuncText+=' if(crntWidth<'+fieldName+'.width){crntWidth <- '+fieldName+'.width}'
handleClicksFuncText = ' ' + fieldName + '.primaryClick(event)'
return [
structText, updateFuncText, drawFuncText, setPosFuncText,
handleClicksFuncText
]
def apply(classes, tags, proxyStyle, className, funcName, platformTag):
print('APPLY: in pattern_WriteCallProxy.apply: ',proxyStyle, '::', className,'\n')
newParamFields = ''
runParams = ''
structRef = findStructRef(classes[0], className)
funcSpec = getFieldSpec(funcName, structRef)
typeSpec = funcSpec['typeSpec']
fieldOwner = typeSpec['owner']
argList = typeSpec['argList']
fieldType = typeSpec['fieldType']
if className[0] == '%': className = className[1:]
callbackName = className+'_'+funcName+'_CB'
bundleName = className+'_'+funcName+'_bundle'
if proxyStyle == "bundledArgs" and platformTag == "Linux":
#print "Linux BundledArgs: ", callbackName, typeSpec
if len(argList)>0:
count=0
for arg in argList:
argName = arg['fieldName']
argTypeSpec = arg['typeSpec']
argOwner = argTypeSpec['owner']
argFieldType = progSpec.getFieldType(argTypeSpec)
if not isinstance(argFieldType, str): argFieldType=argFieldType[0]
if count > 0:
runParams = runParams+', '
newParamFields = newParamFields+ ' '
runParams = runParams+' bundle.'+argName
newParamFields = newParamFields + argOwner+' '+ argFieldType+': '+ argName + '\n'
count = count + 1
CODE = '''
struct GLOBAL {
bool: '''+callbackName+'''(their '''+bundleName+''': bundle) <- {
bundle._object.'''+funcName+'''('''+runParams+''')
return(false)
}
}
struct '''+bundleName+''' {
their '''+className+''': _object
'''+newParamFields+'''
}\n'''
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE, callbackName)
elif proxyStyle == "bundledArgs" and platformTag == "Android":
#print "Android BundledArgs: ", callbackName, funcSpec
if len(argList)>0:
count=0
for arg in argList:
argName = arg['fieldName']
argTypeSpec = arg['typeSpec']
argOwner = argTypeSpec['owner']
argFieldType = progSpec.getFieldType(argTypeSpec)
if not isinstance(argFieldType, str): argFieldType=argFieldType[0]
if count > 0:
runParams = runParams+', '
newParamFields = newParamFields+ ' '
runParams=runParams+argName
newParamFields = newParamFields + argOwner+' '+ argFieldType+': '+ argName + '\n'
count = count + 1
CODE = '''
struct '''+bundleName+''': implements=Runnable{
their '''+className+''': objToCall
'''+newParamFields+'''
void: run() <- {
objToCall.'''+funcName+'''('''+runParams+''')
}
}\n'''
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE, callbackName)
elif proxyStyle == "widgetData" and platformTag == "Linux":
#print "Linux widgetData: ", callbackName, funcSpec
CODE = '''
struct GLOBAL {
void: '''+callbackName+'''(their GtkWidget: wid, their '''+className+''': _obj) <- {
_obj.'''+funcName+'''()
}
}\n'''
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE, callbackName)
elif proxyStyle == "widgetData" and platformTag == "Android":
pass
elif proxyStyle == "widgetEventData" and platformTag == "Linux":
#print "Linux widgetEventData: ", callbackName, funcSpec
CODE = '''
struct GLOBAL {
void: '''+callbackName+'''(their GtkWidget: wid, their GdkEvent: event, their '''+className+''': _obj) <- {
_obj.'''+funcName+'''()
}
}\n'''
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE, callbackName)
elif proxyStyle == "widgetEventData" and platformTag == "Android":
pass
elif platformTag == "IOS": pass
else: print("###ERROR: unknown proxyStyle & Platform: ", proxyStyle, platformTag); exit(1)
