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 adjustConditional(S2, conditionType):
#print "CONDITIONTYPE:", conditionType, '[', S2, ']'
if not isinstance(conditionType, basestring):
if conditionType['owner'] == 'our' or conditionType[
'owner'] == 'their' or conditionType[
'owner'] == 'my' or progSpec.isStruct(
conditionType['fieldType']):
S2 += " != null"
elif conditionType['owner'] == 'me' and (
conditionType['fieldType'] == 'flag'
or progSpec.typeIsInteger(conditionType['fieldType'])):
S2 += " != 0"
conditionType = 'bool'
return [S2, conditionType]
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 adjustConditional(S2, conditionType):
if conditionType!=None and not isinstance(conditionType, str):
#print "ADJUST IF:", S2, conditionType
if conditionType['owner']=='our' or conditionType['owner']=='their' or conditionType['owner']=='my' or progSpec.isStruct(conditionType['fieldType']):
if S2[-1]=='!': S2=S2[:-1] # Todo: Better detect this
S2+=" != nil"
elif conditionType['owner']=='me' and (conditionType['fieldType']=='flag' or progSpec.typeIsInteger(conditionType['fieldType'])):
if S2[-1]=='!': S2=S2[:-1] # Todo: Better detect this
S2+=" != 0"
conditionType='bool'
return [S2, conditionType]