def chooseVirtualRValOwner(LVAL, RVAL):
# Returns left and right text decorations for RHS of function arguments, return values, etc.
if RVAL==0 or RVAL==None or isinstance(RVAL, str): return ['',''] # This happens e.g., string.size() # TODO: fix this.
if LVAL==0 or LVAL==None or isinstance(LVAL, str): return ['', '']
LeftOwner =progSpec.getTypeSpecOwner(LVAL)
RightOwner=progSpec.getTypeSpecOwner(RVAL)
if LeftOwner == RightOwner: return ["", ""]
if LeftOwner!='itr' and RightOwner=='itr': return ["", ".value"]
if LeftOwner=='me' and progSpec.typeIsPointer(RVAL): return ['', '']
if progSpec.typeIsPointer(LVAL) and RightOwner=='me': return ['', '']
#if LeftOwner=='their' and (RightOwner=='our' or RightOwner=='my'): return ['','.get()']
return ['','']
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 xlateLangType(TypeSpec, owner, fieldType, varMode, xlator):
fieldAttrs=''
langType = adjustBaseTypes(fieldType)
if varMode != 'alloc':
fieldAttrs = applyOwner(owner, langType, varMode)
if 'arraySpec' in TypeSpec:
arraySpec=TypeSpec['arraySpec']
if(arraySpec): # Make list, map, etc
[containerType, idxType, owner]=getContainerType(TypeSpec, '')
if 'owner' in TypeSpec['arraySpec']:
containerOwner=TypeSpec['arraySpec']['owner']
else: containerOwner='me'
idxType=adjustBaseTypes(idxType)
if idxType=='timeValue': idxType = 'Int64'
if containerType=='list':
langType="[ "+langType+" ]"
elif containerType=='map':
langType="#2 NSMutableOrderedSet< "+idxType+', '+langType+" >"
elif containerType=='multimap':
langType="multimap< "+idxType+', '+langType+" >"
if varMode != 'alloc':
fieldAttrs=applyOwner(containerOwner, langType, varMode)
if varMode != 'alloc' and progSpec.typeIsPointer(TypeSpec):
langType+='?' # Make pointer func args optionals
return [langType, fieldAttrs] # E.g.: langType='uint', file
def checkForTypeCastNeed(LHS_Type, RHS_Type, codeStr):
LHS_KeyType = progSpec.fieldTypeKeyword(LHS_Type)
RHS_KeyType = progSpec.fieldTypeKeyword(RHS_Type)
if LHS_KeyType == 'bool' and progSpec.typeIsPointer(RHS_KeyType):
return '(' + codeStr + ' != null)'
if LHS_KeyType == 'bool' and RHS_KeyType == 'int':
return '(' + codeStr + ' != 0)'
return codeStr
def getTheDerefPtrMods(itemTypeSpec):
if itemTypeSpec!=None and isinstance(itemTypeSpec, dict) and 'owner' in itemTypeSpec:
if progSpec.typeIsPointer(itemTypeSpec):
owner=progSpec.getTypeSpecOwner(itemTypeSpec)
if owner=='itr':
containerType = itemTypeSpec['arraySpec'][2]
if containerType =='map' or containerType == 'multimap':
return ['', '->value', False]
return ['', '', False]
return ['', '', False]
def determinePtrConfigForAssignments(LVAL, RVAL, assignTag, codeStr):
#TODO: make test case
# Returns left and right text decorations for both LHS and RHS of assignment
if RVAL==0 or RVAL==None or isinstance(RVAL, str): return ['','', '',''] # This happens e.g., string.size() # TODO: fix this.
if LVAL==0 or LVAL==None or isinstance(LVAL, str): return ['','', '','']
LeftOwner =progSpec.getTypeSpecOwner(LVAL)
RightOwner=progSpec.getTypeSpecOwner(RVAL)
if progSpec.typeIsPointer(LVAL) and progSpec.typeIsPointer(RVAL):
if assignTag=='deep' :return ['','', '','']
else: return ['','', '', '']
if LeftOwner == RightOwner: return ['','', '','']
if LeftOwner=='me' and progSpec.typeIsPointer(RVAL):
[leftMod, rightMod] = getTheDerefPtrMods(RVAL)
return ['','', leftMod, rightMod] # ['', '', "(*", ")"]
if progSpec.typeIsPointer(LVAL) and RightOwner=='me':
if assignTag=='deep' :return ['','', '', '']
else: return ['','', "", '']
#if LeftOwner=='their' and (RightOwner=='our' or RightOwner=='my'): return ['','', '','.get()']
return ['','', '','']
def codeFactor(item, objsRefed, returnType, xlator):
#### ( value | ('(' + expr + ')') | ('!' + expr) | ('-' + expr) | varFuncRef)
#print ' factor: ', item
S = ''
retTypeSpec = 'noType'
item0 = item[0]
#print "ITEM0=", item0, ">>>>>", item
if (isinstance(item0, basestring)):
if item0 == '(':
[S2, retTypeSpec] = codeExpr(item[1], objsRefed, returnType,
xlator)
S += '(' + S2 + ')'
elif item0 == '!':
[S2, retTypeSpec] = codeExpr(item[1], objsRefed, returnType,
xlator)
if (progSpec.typeIsPointer(retTypeSpec)):
S = '(' + S2 + ' == null)'
retTypeSpec = 'bool'
else:
S += '!' + S2
elif item0 == '-':
[S2, retTypeSpec] = codeExpr(item[1], objsRefed, returnType,
xlator)
S += '-' + S2
elif item0 == '[':
count = 0
tmp = "(Arrays.asList("
for expr in item[1:-1]:
count += 1
[S2, retTypeSpec] = codeExpr(expr, objsRefed, returnType,
xlator)
if count > 1: tmp += ", "
tmp += S2
tmp += "))"
S += "new " + "ArrayList<>" + tmp # ToDo: make this handle things other than long.
else:
retTypeSpec = 'string'
if (item0[0] == "'"): S += codeUserMesg(item0[1:-1], xlator)
elif (item0[0] == '"'): S += '"' + item0[1:-1] + '"'
else: S += item0
else:
if isinstance(item0[0], basestring):
S += item0[0]
else:
[codeStr, retTypeSpec, prntType,
AltIDXFormat] = codeItemRef(item0, 'RVAL', objsRefed, returnType,
xlator)
if (codeStr == "NULL"): codeStr = "null"
S += codeStr # Code variable reference or function call
return [S, retTypeSpec]
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 getWidgetHandlingCode(classes, fldCat, fieldName, field, structTypeName, dialogStyle, indent):
# _Dialog_GUI is editable widget
global newWidgetFields
global widgetInitFuncCode
global widgetFromVarsCode
global varsFromWidgetCode
label = deCamelCase(fieldName)
[fieldSpec, params] = getFieldSpec(fldCat, field)
typeName = fieldSpec+'Widget'
CasedFieldName = fieldName[0].upper() + fieldName[1:]
widgetName = CasedFieldName + 'Widget'
fieldType = field['typeSpec']['fieldType'][0]
typeSpec = field['typeSpec']
widgetBoxName = widgetName
localWidgetVarName = widgetName
if fieldType=='timeValue':
typeName = 'dateWidget'
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName + ' <- '+ widgetName+'.makeDateWidget("'+label+'")\n'
widgetFromVarsCode += " " + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += " "+currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='widget':
typeName = CasedFieldName +'Widget'
widgetName = fieldName +'Widget'
widgetBoxName = fieldName
localWidgetVarName = fieldName
newWidgetFields += ' their GUI_item' + ': ' + fieldName + '\n'
makeTypeNameCall = widgetName+" <- Data." + fieldName + "\n" + fieldName + '<- '+widgetName+".init()\n"
elif fieldSpec=='struct':
typeName = 'GUI_Frame'
guiStructName = structTypeName + '_Dialog_GUI'
guiMgrName = fieldType + '_GUI_Mgr'
if progSpec.typeIsPointer(typeSpec): widgetInitFuncCode += ' Allocate('+currentClassName+'_data.'+fieldName+')\n'
widgetInitFuncCode += ' Allocate('+guiMgrName+')\n'
makeTypeNameCall = widgetName+' <- '+guiMgrName+'.make'+structTypeName+'Widget('+currentClassName+'_data.'+fieldName+')\n'
newWidgetFields += ' our ' + guiStructName + ': '+ guiMgrName+'\n'
widgetFromVarsCode += ' ' + guiMgrName+ '.setValue(var.'+fieldName+')\n'
varsFromWidgetCode += ' ' + guiMgrName + '.getValue()\n'
elif fieldSpec=='enum':
typeName = 'enumWidget'
EnumItems=[]
for enumItem in params: EnumItems.append('"'+deCamelCase(enumItem)+'"')
optionString = '[' + ', '.join(EnumItems) + ']'
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName+' <- '+ widgetName+'.makeEnumWidget("'+label+'", '+optionString+')\n'
widgetFromVarsCode += ' ' + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' '+currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='string':
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName + ' <- '+ widgetName+'.makeStringWidget("'+label+'")\n'
widgetFromVarsCode += ' ' + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' ' +currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='int':
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName + ' <- '+ widgetName+'.makeIntWidget("'+label+'")\n'
widgetFromVarsCode += " " + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += " "+currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='bool':
widgetBoxName = widgetName +'.box'
makeTypeNameCall = "Allocate("+widgetName+"); " + widgetBoxName + ' <- '+ widgetName+'.makeBoolWidget("'+label+'")\n'
widgetFromVarsCode += ' ' + widgetName+ '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' ' + currentClassName+"_data." + fieldName + ' <- ' + widgetName + '.getValue()\n'
elif fieldSpec=='list' or fieldSpec=='map': pass
else: print"pattern_MakeGUI.getWidgetHandlingCode fieldSpec not specified: ", fieldSpec; exit(2)
# If this is a list or map, populate it
if progSpec.isAContainer(typeSpec):
makeTypeNameCall = widgetName+' <- make'+typeName[0].upper() + typeName[1:]+'("'+label+'")\n'
innerFieldType = typeSpec['fieldType']
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
# If it hasn't already been added, make a struct <ItemType>_ListWidgetManager:ListWidgetManager{}
listManagerStructName = structTypeName+'_ListWidgetManager'
codeListWidgetManagerClassOverride(classes, listManagerStructName, structTypeName)
listWidMgrName = widgetName+'_LEWM'
newWidgetFields += ' me '+listManagerStructName+': '+listWidMgrName+'\n'
widgetListEditorName = widgetName+'_Editor'
localWidgetVarName = widgetListEditorName
if progSpec.typeIsPointer(typeSpec): widgetInitFuncCode += ' Allocate('+currentClassName+'_data.'+fieldName+')\n'
widgetInitFuncCode += ' their GUI_item: '+widgetListEditorName+' <- '+listWidMgrName+'.initWidget('+currentClassName+'_data.'+fieldName+')\n'
widgetInitFuncCode += ' addToContainer(box, '+widgetListEditorName+')\n'
widgetFromVarsCode += " " + listWidMgrName + '.setValue(var.'+ fieldName +')\n'
# varsFromWidgetCode += " " + listWidMgrName + ' <- ' + widgetName + '.getValue()\n'
else: # Not an ArraySpec:
newWidgetFields += ' our '+typeName+': '+widgetName+'\n'
widgetInitFuncCode += ' '+makeTypeNameCall
widgetInitFuncCode += ' addToContainer(box, '+widgetBoxName+')\n'
if dialogStyle == 'TabbedStack':
widgetInitFuncCode+=' '+'gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(box), '+ localWidgetVarName+', "'+label+'")\n'
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 getWidgetHandlingCode(classes, fldCat, fieldName, field, structTypeName,
dialogStyle, classPrimaryGuiItem, classOptionsTags,
indent):
# _Dialog_GUI is editable widget
global newWidgetFields
global widgetInitFuncCode
global widgetFromVarsCode
global varsFromWidgetCode
global clearWidgetCode
label = deCamelCase(fieldName)
[fieldSpec, params] = getFieldSpec(fldCat, field)
typeName = fieldSpec + 'Widget'
CasedFieldName = fieldName[0].upper() + fieldName[1:]
widgetName = CasedFieldName + 'Widget'
typeSpec = field['typeSpec']
innerFieldType = typeSpec['fieldType']
fieldType = innerFieldType[0]
widgetBoxName = widgetName
localWidgetVarName = widgetName
makeTypeNameCall = ''
if fieldType == 'timeValue':
typeName = 'dateWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ');\n' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'Agreement':
typeName = 'AgreeWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + fieldName + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ''
varsFromWidgetCode += ''
elif fieldType == 'DateValue':
typeName = 'DateWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initCrnt("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ''
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'timeOfDay':
typeName = 'TimeWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initCrnt("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ''
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'DateTime':
typeName = 'DateTimeWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initCrnt("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ''
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'FoodData':
typeName = 'FoodDataWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", _data.' + fieldName + ')\n'
#widgetFromVarsCode += ' '+widgetName+'.setValue(var.'+ fieldName +')\n'
#varsFromWidgetCode += ' '+widgetName+'.getValue()\n'
elif fieldType == 'MedItemData':
typeName = 'MedItemDataWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", _data.' + fieldName + ')\n'
#widgetFromVarsCode += ' '+widgetName+'.setValue(var.'+ fieldName +')\n'
#varsFromWidgetCode += ' '+widgetName+'.getValue()\n'
elif fieldType == 'MedData':
typeName = 'MedBunchDataWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += 'Allocate(_data.' + fieldName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", _data.' + fieldName + ')\n'
#widgetFromVarsCode += ' '+widgetName+'.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldType == 'matterTerm':
typeName = 'MatterTermWidget'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", _data.' + fieldName + ')\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'widget':
typeName = fieldType
localWidgetVarName = fieldName
if fieldType == 'graphWidget':
widgetName = fieldName + 'Widget'
widgetBoxName = fieldName
newWidgetFields += ' their GUI_item' + ': ' + fieldName + '\n'
makeTypeNameCall = widgetName + ' <- Data.' + fieldName + '\n' + fieldName + '<- ' + widgetName + '.init("' + label + '")\n'
else:
widgetBoxName = widgetName + '.box'
dataType = changeDataFieldType(classes, structTypeName, typeSpec)
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
elif fieldSpec == 'struct':
typeName = 'GUI_Frame'
guiStructName = structTypeName + '_Dialog_GUI'
guiMgrName = fieldType + '_GUI_Mgr'
if progSpec.typeIsPointer(typeSpec):
widgetInitFuncCode += ' Allocate(_data.' + fieldName + ')\n'
widgetInitFuncCode += 'Allocate(' + guiMgrName + ')\n'
makeTypeNameCall = widgetName + ' <- ' + guiMgrName + '.initWidget(_data.' + fieldName + ')\n'
makeTypeNameCall += ' ' + guiMgrName + '.parentGuiMgr <- self\n'
newWidgetFields += ' our ' + guiStructName + ': ' + guiMgrName + '\n'
widgetFromVarsCode += ' ' + guiMgrName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' ' + guiMgrName + '.getValue()\n'
clearWidgetCode += ' ' + guiMgrName + '.clear()\n'
makeTypeNameCall += ' ' + guiMgrName + '.load()\n'
elif fieldSpec == 'enum':
typeName = 'enumWidget'
EnumItems = []
for enumItem in params:
EnumItems.append('"' + deCamelCase(enumItem) + '"')
optionString = '[' + ', '.join(EnumItems) + ']'
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + '); ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '", ' + optionString + ')\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'string':
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + '); ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'int':
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + ')\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
if progSpec.typeIsNumRange(innerFieldType):
range1 = innerFieldType[0]
range2 = innerFieldType[2]
makeTypeNameCall += ' ' + widgetName + '.minValue <- ' + range1 + '\n ' + widgetName + '.maxValue <- ' + range2 + '\n'
makeTypeNameCall += ' ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'bool':
widgetBoxName = widgetName + '.box'
makeTypeNameCall = 'Allocate(' + widgetName + '); ' + widgetBoxName + ' <- ' + widgetName + '.initWidget("' + label + '")\n'
makeTypeNameCall += ' ' + widgetName + '.parentGuiMgr <- self\n'
widgetFromVarsCode += ' ' + widgetName + '.setValue(var.' + fieldName + ')\n'
varsFromWidgetCode += ' _data.' + fieldName + ' <- ' + widgetName + '.getValue()\n'
clearWidgetCode += ' ' + widgetName + '.clear()\n'
elif fieldSpec == 'list' or fieldSpec == 'map':
pass
else:
print(
'pattern_MakeGUI.getWidgetHandlingCode fieldSpec not specified: ',
fieldSpec)
exit(2)
if typeName == 'GUI_Frame': owner = 'their '
else: owner = 'our '
# If this is a list or map, populate it
if progSpec.isAContainer(typeSpec):
makeTypeNameCall = widgetName + ' <- make' + typeName[0].upper(
) + typeName[1:] + '("' + label + '")\n'
fldCatInner = progSpec.innerTypeCategory(innerFieldType)
# If it hasn't already been added, make a struct <ItemType>_ListWidgetManager:ListWidgetManager{}
listManagerStructName = structTypeName + '_ListWidgetManager'
getListWidgetMgrCode(classes, listManagerStructName, structTypeName,
fieldName, classOptionsTags)
listWidMgrName = 'LEWM'
newWidgetFields += ' me ' + listManagerStructName + ': ' + listWidMgrName + '\n'
widgetListEditorName = widgetName + '_Editor'
localWidgetVarName = widgetListEditorName
if progSpec.typeIsPointer(typeSpec):
widgetInitFuncCode += 'Allocate(_data.' + fieldName + ')\n'
widgetInitFuncCode += ' their GUI_YStack: ' + widgetListEditorName + ' <- ' + listWidMgrName + '.initWidget(_data.' + fieldName + ', "' + label + '")\n'
if classPrimaryGuiItem == fieldName:
widgetInitFuncCode += ' addToContainerAndExpand(box, ' + widgetListEditorName + ')\n'
else:
widgetInitFuncCode += ' addToContainer(box, ' + widgetListEditorName + ')\n'
# widgetFromVarsCode += ' ' + listWidMgrName + '.setValue(var.'+ fieldName +')\n'
varsFromWidgetCode += ' ' + listWidMgrName + '.getValue()\n'
clearWidgetCode += ' ' + listWidMgrName + '.clear()\n'
elif dialogStyle == 'WizardStack':
newWidgetFields += ' ' + owner + typeName + ': ' + widgetName + '\n'
widgetInitFuncCode += ' ' + makeTypeNameCall
widgetInitFuncCode += ' addToZStack(wiz.ZStack, ' + widgetBoxName + ', "' + CasedFieldName + '")\n'
widgetInitFuncCode += ' wiz.children.pushLast("' + CasedFieldName + '")\n'
elif dialogStyle == 'Z_stack':
widgetBoxName = guiMgrName + '.box'
newWidgetFields += ' ' + owner + typeName + ': ' + widgetName + '\n'
widgetInitFuncCode += ' ' + makeTypeNameCall + '\n'
widgetInitFuncCode += ' addToZStack(Zbox, ' + widgetBoxName + ', "' + CasedFieldName + '")\n'
widgetInitFuncCode += ' children.pushLast("' + CasedFieldName + '")\n'
else: # Not an ArraySpec:
newWidgetFields += ' ' + owner + typeName + ': ' + widgetName + '\n'
widgetInitFuncCode += ' ' + makeTypeNameCall
if classPrimaryGuiItem == fieldName:
widgetInitFuncCode += ' addToContainerAndExpand(box, ' + widgetBoxName + ')\n'
else:
widgetInitFuncCode += ' addToContainerAndExpand(box, ' + widgetBoxName + ')\n'
if dialogStyle == 'TabbedStack':
widgetInitFuncCode += ' ' + 'setTabLabelText(box, ' + localWidgetVarName + ', "' + label + '")\n'
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 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 LanguageSpecificDecorations(S, segType, owner):
if segType!= 0 and progSpec.typeIsPointer(segType) and owner!='itr' and S!='NULL' and S[-1]!=']':
S+='!' # optionals
return S
