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