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