From c44f2b4c4ec174e25d9fed96e32bcdf954c601e1 Mon Sep 17 00:00:00 2001 From: Mario Bucev Date: Mon, 9 Sep 2024 16:12:29 +0300 Subject: [PATCH] Remove 'TypeEncodingKind' --- BackendAst/DAstACN.fs | 213 +++++++++++++++++----------------------- BackendAst/DAstUPer.fs | 73 ++++++-------- CommonTypes/FsUtils.fs | 4 +- FrontEndAst/DAst.fs | 22 ----- FrontEndAst/Language.fs | 16 --- StgScala/acn_scala.stg | 2 - 6 files changed, 120 insertions(+), 210 deletions(-) diff --git a/BackendAst/DAstACN.fs b/BackendAst/DAstACN.fs index 9e03a4d46..bfacdb1f5 100644 --- a/BackendAst/DAstACN.fs +++ b/BackendAst/DAstACN.fs @@ -114,7 +114,7 @@ let handleSavePosition (funcBody: FuncBody) Some {bodyResult with funcBody = funcBodyStr} | None -> let funcBodyStr = savePositionStatement - Some {funcBody = funcBodyStr; errCodes =[]; localVariables = []; bValIsUnReferenced= true; bBsIsUnReferenced=false; resultExpr = None; typeEncodingKind = None; auxiliaries = []; icdResult = None } + Some {funcBody = funcBodyStr; errCodes =[]; localVariables = []; bValIsUnReferenced= true; bBsIsUnReferenced=false; resultExpr = None; auxiliaries = []; icdResult = None } newContent, ns1a newFuncBody @@ -150,7 +150,7 @@ let handleAlignmentForAsn1Types (r:Asn1AcnAst.AstRoot) Some {bodyResult with funcBody = funcBodyStr} | None -> let funcBodyStr = alignToNext "" alStr nAlignmentVal nestingScope.acnOffset (nestingScope.acnOuterMaxSize - nestingScope.acnOffset) (nestingScope.nestingLevel - 1I) nestingScope.nestingIx nestingScope.acnRelativeOffset codec - Some {funcBody = funcBodyStr; errCodes =[errCode]; localVariables = []; bValIsUnReferenced= true; bBsIsUnReferenced=false; resultExpr = None; typeEncodingKind = None; auxiliaries = []; icdResult=None} + Some {funcBody = funcBodyStr; errCodes =[errCode]; localVariables = []; bValIsUnReferenced= true; bBsIsUnReferenced=false; resultExpr = None; auxiliaries = []; icdResult=None} newContent, ns1a newFuncBody @@ -176,7 +176,7 @@ let handleAlignmentForAcnTypes (r:Asn1AcnAst.AstRoot) Some {bodyResult with funcBody = funcBodyStr} | None -> let funcBodyStr = alignToNext "" alStr nAlignmentVal nestingScope.acnOffset (nestingScope.acnOuterMaxSize - nestingScope.acnOffset) (nestingScope.nestingLevel - 1I) nestingScope.nestingIx nestingScope.acnRelativeOffset codec - Some {funcBody = funcBodyStr; errCodes =[]; localVariables = []; bValIsUnReferenced= true; bBsIsUnReferenced=false; resultExpr = None; typeEncodingKind = None; auxiliaries = []; icdResult= None} + Some {funcBody = funcBodyStr; errCodes =[]; localVariables = []; bValIsUnReferenced= true; bBsIsUnReferenced=false; resultExpr = None; auxiliaries = []; icdResult= None} newContent newFuncBody @@ -417,77 +417,61 @@ let private createAcnIntegerFunctionInternal (r:Asn1AcnAst.AstRoot) let funcBodyContent = match acnEncodingClass with |Asn1AcnAst.Integer_uPER -> - uperfuncBody errCode nestingScope p true |> Option.map(fun x -> x.funcBody, x.errCodes, x.bValIsUnReferenced, x.bBsIsUnReferenced, x.typeEncodingKind) + uperfuncBody errCode nestingScope p true |> Option.map(fun x -> x.funcBody, x.errCodes, x.bValIsUnReferenced, x.bBsIsUnReferenced) |Asn1AcnAst.PositiveInteger_ConstSize_8 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = Positive; endianness = Byte} - Some(PositiveInteger_ConstSize_8 (castPp 8) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 8) codec, [errCode], false, false, Some typeEncodingKind) + Some(PositiveInteger_ConstSize_8 (castPp 8) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 8) codec, [errCode], false, false) |Asn1AcnAst.PositiveInteger_ConstSize_big_endian_16 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = Positive; endianness = BigEndian S16} - Some(PositiveInteger_ConstSize_big_endian_16 (castPp 16) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 16) codec, [errCode], false, false, Some typeEncodingKind) + Some(PositiveInteger_ConstSize_big_endian_16 (castPp 16) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 16) codec, [errCode], false, false) |Asn1AcnAst.PositiveInteger_ConstSize_little_endian_16 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = Positive; endianness = LittleEndian S16} - Some(PositiveInteger_ConstSize_little_endian_16 (castPp 16) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 16) codec, [errCode], false, false, Some typeEncodingKind) + Some(PositiveInteger_ConstSize_little_endian_16 (castPp 16) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 16) codec, [errCode], false, false) |Asn1AcnAst.PositiveInteger_ConstSize_big_endian_32 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = Positive; endianness = BigEndian S32} - Some(PositiveInteger_ConstSize_big_endian_32 (castPp 32) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 32) codec, [errCode], false, false, Some typeEncodingKind) + Some(PositiveInteger_ConstSize_big_endian_32 (castPp 32) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 32) codec, [errCode], false, false) |Asn1AcnAst.PositiveInteger_ConstSize_little_endian_32 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = Positive; endianness = LittleEndian S32} - Some(PositiveInteger_ConstSize_little_endian_32 (castPp 32) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 32) codec, [errCode], false, false, Some typeEncodingKind) + Some(PositiveInteger_ConstSize_little_endian_32 (castPp 32) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 32) codec, [errCode], false, false) |Asn1AcnAst.PositiveInteger_ConstSize_big_endian_64 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = Positive; endianness = BigEndian S64} - Some(PositiveInteger_ConstSize_big_endian_64 (castPp 64) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 64) codec, [errCode], false, false, Some typeEncodingKind) + Some(PositiveInteger_ConstSize_big_endian_64 (castPp 64) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 64) codec, [errCode], false, false) |Asn1AcnAst.PositiveInteger_ConstSize_little_endian_64 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = Positive; endianness = LittleEndian S64} - Some(PositiveInteger_ConstSize_little_endian_64 (castPp 64) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 64) codec, [errCode], false, false, Some typeEncodingKind) + Some(PositiveInteger_ConstSize_little_endian_64 (castPp 64) sSsuffix errCode.errCodeName soMF soMFM (max 0I nUperMin) (uIntActualMax 64) codec, [errCode], false, false) |Asn1AcnAst.PositiveInteger_ConstSize bitSize -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = Positive; endianness = Unbounded} - Some(PositiveInteger_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName ( bitSize) soMF soMFM (max 0I nUperMin) (uIntActualMax (int bitSize)) codec, [errCode], false, false, Some typeEncodingKind) + Some(PositiveInteger_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName ( bitSize) soMF soMFM (max 0I nUperMin) (uIntActualMax (int bitSize)) codec, [errCode], false, false) |Asn1AcnAst.TwosComplement_ConstSize_8 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = TwosComplement; endianness = Byte} - Some(TwosComplement_ConstSize_8 (castPp 8) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 8) (sIntActualMax 8) codec, [errCode], false, false, Some typeEncodingKind) + Some(TwosComplement_ConstSize_8 (castPp 8) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 8) (sIntActualMax 8) codec, [errCode], false, false) |Asn1AcnAst.TwosComplement_ConstSize_big_endian_16 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = TwosComplement; endianness = BigEndian S16} - Some(TwosComplement_ConstSize_big_endian_16 (castPp 16) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 16) (sIntActualMax 16) codec, [errCode], false, false, Some typeEncodingKind) + Some(TwosComplement_ConstSize_big_endian_16 (castPp 16) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 16) (sIntActualMax 16) codec, [errCode], false, false) |Asn1AcnAst.TwosComplement_ConstSize_little_endian_16 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = TwosComplement; endianness = LittleEndian S16} - Some(TwosComplement_ConstSize_little_endian_16 (castPp 16) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 16) (sIntActualMax 16) codec, [errCode], false, false, Some typeEncodingKind) + Some(TwosComplement_ConstSize_little_endian_16 (castPp 16) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 16) (sIntActualMax 16) codec, [errCode], false, false) |Asn1AcnAst.TwosComplement_ConstSize_big_endian_32 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = TwosComplement; endianness = BigEndian S32} - Some(TwosComplement_ConstSize_big_endian_32 (castPp 32) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 32) (sIntActualMax 32) codec, [errCode], false, false, Some typeEncodingKind) + Some(TwosComplement_ConstSize_big_endian_32 (castPp 32) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 32) (sIntActualMax 32) codec, [errCode], false, false) |Asn1AcnAst.TwosComplement_ConstSize_little_endian_32 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = TwosComplement; endianness = LittleEndian S32} - Some(TwosComplement_ConstSize_little_endian_32 (castPp 32) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 32) (sIntActualMax 32) codec, [errCode], false, false, Some typeEncodingKind) + Some(TwosComplement_ConstSize_little_endian_32 (castPp 32) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 32) (sIntActualMax 32) codec, [errCode], false, false) |Asn1AcnAst.TwosComplement_ConstSize_big_endian_64 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = TwosComplement; endianness = BigEndian S64} - Some(TwosComplement_ConstSize_big_endian_64 (castPp 64) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 64) (sIntActualMax 64) codec, [errCode], false, false, Some typeEncodingKind) + Some(TwosComplement_ConstSize_big_endian_64 (castPp 64) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 64) (sIntActualMax 64) codec, [errCode], false, false) |Asn1AcnAst.TwosComplement_ConstSize_little_endian_64 -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = TwosComplement; endianness = LittleEndian S64} - Some(TwosComplement_ConstSize_little_endian_64 (castPp 64) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 64) (sIntActualMax 64) codec, [errCode], false, false, Some typeEncodingKind) + Some(TwosComplement_ConstSize_little_endian_64 (castPp 64) sSsuffix errCode.errCodeName soMF soMFM (sIntActualMin 64) (sIntActualMax 64) codec, [errCode], false, false) |Asn1AcnAst.TwosComplement_ConstSize bitSize -> - let typeEncodingKind = AcnIntegerEncodingType {signedness = TwosComplement; endianness = Unbounded} - Some(TwosComplement_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM ( bitSize) (sIntActualMin (int bitSize)) (sIntActualMax (int bitSize)) codec, [errCode], false, false, Some typeEncodingKind) + Some(TwosComplement_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM ( bitSize) (sIntActualMin (int bitSize)) (sIntActualMax (int bitSize)) codec, [errCode], false, false) |Asn1AcnAst.ASCII_ConstSize size -> - Some(ASCII_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax ((size)/8I) codec, [errCode], false, false, Some Placeholder) // TODO: Placeholder + Some(ASCII_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax ((size)/8I) codec, [errCode], false, false) |Asn1AcnAst.ASCII_VarSize_NullTerminated nullBytes -> - Some(ASCII_VarSize_NullTerminated (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax nullBytes codec, [errCode], false, false, Some Placeholder) + Some(ASCII_VarSize_NullTerminated (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax nullBytes codec, [errCode], false, false) |Asn1AcnAst.ASCII_UINT_ConstSize size -> - Some(ASCII_UINT_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax (( size)/8I) codec, [errCode], false, false, Some Placeholder) + Some(ASCII_UINT_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax (( size)/8I) codec, [errCode], false, false) |Asn1AcnAst.ASCII_UINT_VarSize_NullTerminated nullBytes -> - Some(ASCII_UINT_VarSize_NullTerminated (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax nullBytes codec, [errCode], false, false, Some Placeholder) + Some(ASCII_UINT_VarSize_NullTerminated (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax nullBytes codec, [errCode], false, false) |Asn1AcnAst.BCD_ConstSize size -> - Some(BCD_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax (( size)/4I) codec, [errCode], false, false, Some Placeholder) + Some(BCD_ConstSize (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax (( size)/4I) codec, [errCode], false, false) |Asn1AcnAst.BCD_VarSize_NullTerminated nullBytes -> - Some(BCD_VarSize_NullTerminated (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax codec, [errCode], false, false, Some Placeholder) + Some(BCD_VarSize_NullTerminated (castPp word_size_in_bits) sSsuffix errCode.errCodeName soMF soMFM nUperMin nUperMax codec, [errCode], false, false) match funcBodyContent with | None -> None - | Some (funcBodyContent,errCodes, bValIsUnReferenced, bBsIsUnReferenced, typeEncodingKind ) -> + | Some (funcBodyContent,errCodes, bValIsUnReferenced, bBsIsUnReferenced) -> let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType "INTEGER"); sConstraint=sAsn1Constraints; minLengthInBits = acnMinSizeInBits ;maxLengthInBits=acnMaxSizeInBits;sUnits=unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = "INTEGER"; rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = []; bValIsUnReferenced= bValIsUnReferenced; bBsIsUnReferenced=bBsIsUnReferenced; resultExpr = resultExpr; typeEncodingKind = typeEncodingKind; auxiliaries = []; icdResult=Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = []; bValIsUnReferenced= bValIsUnReferenced; bBsIsUnReferenced=bBsIsUnReferenced; resultExpr = resultExpr; auxiliaries = []; icdResult=Some icd}) funcBody let getMappingFunctionModule (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (soMapFuncName:string option) = @@ -604,14 +588,14 @@ let createEnumCommon (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedFieldDe lm.lg.generateIntFullyConstraintRangeAssert (ToC (r.args.TypePrefix + tasInfo.tasName)) p codec | None -> None let funcBody = IntFullyConstraintPos (castPp word_size_in_bits) min max nbits sSsuffix errCode.errCodeName rangeAssert codec - Some({UPERFuncBodyResult.funcBody = funcBody; errCodes = [errCode]; localVariables= []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (Asn1IntegerEncodingType (Some (FullyConstrainedPositive (min, max)))); auxiliaries=[]}) + Some({UPERFuncBodyResult.funcBody = funcBody; errCodes = [errCode]; localVariables= []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=[]}) createAcnIntegerFunctionInternal r lm codec (Concrete (min,max)) intTypeClass o.acnEncodingClass uperInt sAsn1Constraints acnMinSizeInBits acnMaxSizeInBits unitsOfMeasure (None, None) let funcBodyContent = match intFuncBody errCode acnArgs nestingScope pVal with | None -> None | Some intAcnFuncBdResult -> - let resultExpr, errCodes, typeEncodingKind, auxiliaries = - intAcnFuncBdResult.resultExpr, intAcnFuncBdResult.errCodes, intAcnFuncBdResult.typeEncodingKind, intAcnFuncBdResult.auxiliaries + let resultExpr, errCodes, auxiliaries = + intAcnFuncBdResult.resultExpr, intAcnFuncBdResult.errCodes, intAcnFuncBdResult.auxiliaries let mainContent, localVariables = match r.args.isEnumEfficientEnabled o.items.Length with | false -> @@ -625,16 +609,16 @@ let createEnumCommon (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedFieldDe let sEnumIndex = "nEnumIndex" let enumIndexVar = (Asn1SIntLocalVariable (sEnumIndex, None)) Enumerated_no_switch (lm.lg.getValue p.arg) td intAcnFuncBdResult.funcBody errCode.errCodeName sFirstItemName intVal sEnumIndex nLastItemIndex o.encodeValues codec, enumIndexVar::localVar@intAcnFuncBdResult.localVariables - Some (mainContent, resultExpr, errCodes, localVariables, typeEncodingKind, auxiliaries) + Some (mainContent, resultExpr, errCodes, localVariables, auxiliaries) match funcBodyContent with | None -> None - | Some (funcBodyContent, resultExpr, errCodes, localVariables, typeEncodingKind, auxiliaries) -> + | Some (funcBodyContent, resultExpr, errCodes, localVariables, auxiliaries) -> let icdFnc fieldName sPresent (comments:string list) = let newComments = comments@[enumComment icdStgFileName o] [{IcdRow.fieldName = fieldName; comments = newComments; sPresent=sPresent;sType=(IcdPlainType "ENUMERATED"); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = "ENUMERATED"; rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None;} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=typeEncodingKind; auxiliaries=auxiliaries; icdResult=Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=auxiliaries; icdResult=Some icd}) funcBody @@ -682,19 +666,19 @@ let createRealFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedField let funcBodyContent = match o.acnEncodingClass with - | Real_IEEE754_32_big_endian -> Some (Real_32_big_endian castPp sSuffix errCode.errCodeName codec, [errCode], Some (AcnRealEncodingType BigEndian32), []) - | Real_IEEE754_64_big_endian -> Some (Real_64_big_endian pp errCode.errCodeName codec, [errCode], Some (AcnRealEncodingType BigEndian64), []) - | Real_IEEE754_32_little_endian -> Some (Real_32_little_endian castPp sSuffix errCode.errCodeName codec, [errCode], Some (AcnRealEncodingType LittleEndian32), []) - | Real_IEEE754_64_little_endian -> Some (Real_64_little_endian pp errCode.errCodeName codec, [errCode], Some (AcnRealEncodingType LittleEndian64), []) - | Real_uPER -> uperFunc.funcBody_e errCode nestingScope p true |> Option.map(fun x -> x.funcBody, x.errCodes, x.typeEncodingKind, x.auxiliaries) + | Real_IEEE754_32_big_endian -> Some (Real_32_big_endian castPp sSuffix errCode.errCodeName codec, [errCode], []) + | Real_IEEE754_64_big_endian -> Some (Real_64_big_endian pp errCode.errCodeName codec, [errCode], []) + | Real_IEEE754_32_little_endian -> Some (Real_32_little_endian castPp sSuffix errCode.errCodeName codec, [errCode], []) + | Real_IEEE754_64_little_endian -> Some (Real_64_little_endian pp errCode.errCodeName codec, [errCode], []) + | Real_uPER -> uperFunc.funcBody_e errCode nestingScope p true |> Option.map(fun x -> x.funcBody, x.errCodes, x.auxiliaries) match funcBodyContent with | None -> None - | Some (funcBodyContent,errCodes, typeEncodingKind, auxiliaries) -> + | Some (funcBodyContent,errCodes, auxiliaries) -> let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType (getASN1Name t)); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=t.unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = (getASN1Name t); rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=typeEncodingKind; auxiliaries=auxiliaries; icdResult=Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=auxiliaries; icdResult=Some icd}) let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) let annots = match ST.lang with @@ -706,14 +690,14 @@ let createRealFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedField let createObjectIdentifierFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedFieldDependencies) (lm:LanguageMacros) (codec:CommonTypes.Codec) (t:Asn1AcnAst.Asn1Type) (o:Asn1AcnAst.ObjectIdentifier) (typeDefinition:TypeDefinitionOrReference) (isValidFunc: IsValidFunction option) (uperFunc: UPerFunction) (us:State) = let funcBody (errCode:ErrorCode) (acnArgs: (AcnGenericTypes.RelativePath*AcnGenericTypes.AcnParameter) list) (nestingScope: NestingScope) (p:CallerScope) = let funcBodyContent = - uperFunc.funcBody_e errCode nestingScope p true |> Option.map(fun x -> x.funcBody, x.errCodes, x.resultExpr, x.typeEncodingKind, x.auxiliaries) + uperFunc.funcBody_e errCode nestingScope p true |> Option.map(fun x -> x.funcBody, x.errCodes, x.resultExpr, x.auxiliaries) match funcBodyContent with | None -> None - | Some (funcBodyContent,errCodes, resultExpr, typeEncodingKind, auxiliaries) -> + | Some (funcBodyContent,errCodes, resultExpr, auxiliaries) -> let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType (getASN1Name t)); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=t.unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = (getASN1Name t); rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=typeEncodingKind; auxiliaries=auxiliaries; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=auxiliaries; icdResult = Some icd}) let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) createAcnFunction r deps lm codec t typeDefinition isValidFunc (fun us e acnArgs nestingScope p -> funcBody e acnArgs nestingScope p, us) (fun atc -> true) soSparkAnnotations [] us @@ -721,14 +705,14 @@ let createObjectIdentifierFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnI let createTimeTypeFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedFieldDependencies) (lm:LanguageMacros) (codec:CommonTypes.Codec) (t:Asn1AcnAst.Asn1Type) (o:Asn1AcnAst.TimeType) (typeDefinition:TypeDefinitionOrReference) (isValidFunc: IsValidFunction option) (uperFunc: UPerFunction) (us:State) = let funcBody (errCode:ErrorCode) (acnArgs: (AcnGenericTypes.RelativePath*AcnGenericTypes.AcnParameter) list) (nestingScope: NestingScope) (p:CallerScope) = let funcBodyContent = - uperFunc.funcBody_e errCode nestingScope p true |> Option.map(fun x -> x.funcBody, x.errCodes, x.resultExpr, x.typeEncodingKind, x.auxiliaries) + uperFunc.funcBody_e errCode nestingScope p true |> Option.map(fun x -> x.funcBody, x.errCodes, x.resultExpr, x.auxiliaries) match funcBodyContent with | None -> None - | Some (funcBodyContent,errCodes, resultExpr, typeEncodingKind, auxiliaries) -> + | Some (funcBodyContent,errCodes, resultExpr, auxiliaries) -> let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType (getASN1Name t)); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=t.unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = (getASN1Name t); rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None;} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=typeEncodingKind; auxiliaries=auxiliaries; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=auxiliaries; icdResult = Some icd}) let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) createAcnFunction r deps lm codec t typeDefinition isValidFunc (fun us e acnArgs nestingScope p -> funcBody e acnArgs nestingScope p, us) (fun atc -> true) soSparkAnnotations [] us @@ -749,7 +733,7 @@ let createAcnBooleanFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInserte let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType "BOOLEAN"); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=None; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = "BOOLEAN"; rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some {AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind = Some (AcnBooleanEncodingType None); auxiliaries=[]; icdResult = Some icd} + Some {AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=[]; icdResult = Some icd} (funcBody errCode), ns let createBooleanFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedFieldDependencies) (lm:LanguageMacros) (codec:CommonTypes.Codec) (t:Asn1AcnAst.Asn1Type) (o:Asn1AcnAst.Boolean) (typeDefinition:TypeDefinitionOrReference) (baseTypeUperFunc : AcnFunction option) (isValidFunc: IsValidFunction option) (us:State) = @@ -792,7 +776,7 @@ let createBooleanFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedFi [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType (getASN1Name t)); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=t.unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = (getASN1Name t); rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} let aux = lm.lg.generateBooleanAuxiliaries r ACN t o nestingScope p.arg codec - {AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind = Some (AcnBooleanEncodingType o.acnProperties.encodingPattern); auxiliaries=aux; icdResult = Some icd} + {AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=aux; icdResult = Some icd} let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) createAcnFunction r deps lm codec t typeDefinition isValidFunc (fun us e acnArgs nestingScope p -> Some (funcBody e acnArgs nestingScope p), us) (fun atc -> true) soSparkAnnotations [] us @@ -824,7 +808,7 @@ let createAcnNullTypeFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsert let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType icdDesc); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=None; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = "NULL"; rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = ret; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind = Some (AcnNullEncodingType (Some encPattern)); auxiliaries=[]; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = ret; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=[]; icdResult = Some icd}) (funcBody errCode), ns let createNullTypeFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedFieldDependencies) (lm:LanguageMacros) (codec:CommonTypes.Codec) (t:Asn1AcnAst.Asn1Type) (o:Asn1AcnAst.NullType) (typeDefinition:TypeDefinitionOrReference) (isValidFunc: IsValidFunction option) (us:State) = @@ -838,7 +822,7 @@ let createNullTypeFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedF match codec, lm.lg.decodingKind with | Decode, Copy -> // Copy-decoding backend expect all values to be declared even if they are "dummies" - Some ({AcnFuncBodyResult.funcBody = lm.acn.Null_declare pp; errCodes = []; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=Some pp; typeEncodingKind = Some (AcnNullEncodingType None); auxiliaries=aux; icdResult=None}) + Some ({AcnFuncBodyResult.funcBody = lm.acn.Null_declare pp; errCodes = []; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=Some pp; auxiliaries=aux; icdResult=None}) | _ -> None | Some encPattern -> let arrsBits, arrBytes, nBitsSize, icdDesc = @@ -858,7 +842,7 @@ let createNullTypeFunction (r:Asn1AcnAst.AstRoot) (deps: Asn1AcnAst.AcnInsertedF let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType icdDesc); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=t.unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = (getASN1Name t); rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = ret; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= lm.lg.acn.null_valIsUnReferenced; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind = Some (AcnNullEncodingType (Some encPattern)); auxiliaries=aux; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = ret; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= lm.lg.acn.null_valIsUnReferenced; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=aux; icdResult = Some icd}) let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) createAcnFunction r deps lm codec t typeDefinition isValidFunc (fun us e acnArgs nestingScope p -> funcBody e acnArgs nestingScope p, us) (fun atc -> true) soSparkAnnotations [] us @@ -973,7 +957,7 @@ let createStringFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFiel let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType (getASN1Name t)); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=t.unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = (getASN1Name t); rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVars; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind = Some (AcnStringEncodingType o.acnEncodingClass); auxiliaries=auxiliaries; icdResult = Some icd} ), ns + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVars; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=auxiliaries; icdResult = Some icd} ), ns let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) createAcnFunction r deps lm codec t typeDefinition isValidFunc (fun us e acnArgs nestingScope p -> funcBody e acnArgs nestingScope p us) (fun atc -> true) soSparkAnnotations [] us @@ -1035,11 +1019,6 @@ let createAcnStringFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedF nestingIx = nestingScope.nestingIx acnMaxOffset = nestingScope.acnOffset uperMaxOffset = nestingScope.uperOffset - typeInfo = { - uperMaxSizeBits = o.acnEncodingClass.charSizeInBits - acnMaxSizeBits = o.acnEncodingClass.charSizeInBits - typeKind = Some (AcnStringEncodingType o.acnEncodingClass) - } nestingScope = nestingScope cs = p encDec = Some internalItem @@ -1059,7 +1038,7 @@ let createAcnStringFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedF let funcBodyContent,localVariables = DAstUPer.handleFragmentation lm p codec errCode ii o.uperMaxSizeInBits o.minSize.uper o.maxSize.uper internalItem nBits false true funcBodyContent,charIndex@localVariables - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = lv::localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (AcnStringEncodingType o.acnEncodingClass); auxiliaries=auxiliaries} + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = lv::localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=auxiliaries} let funcBody (errCode:ErrorCode) (acnArgs: (AcnGenericTypes.RelativePath*AcnGenericTypes.AcnParameter) list) (nestingScope: NestingScope) (p:CallerScope) = @@ -1096,7 +1075,7 @@ let createAcnStringFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedF let icdFnc fieldName sPresent comments = [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType "IA5String"); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=None; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = "IA5String"; rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCode::errCodes |> List.distinct ; localVariables = lvs; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind = Some (AcnStringEncodingType o.acnEncodingClass); auxiliaries=auxiliaries; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCode::errCodes |> List.distinct ; localVariables = lvs; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=auxiliaries; icdResult = Some icd}) (funcBody errCode), ns @@ -1162,7 +1141,7 @@ let createOctetStringFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInserte [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType (getASN1Name t)); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=t.unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = (getASN1Name t); rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind = Some (AcnOctetStringEncodingType o.acnEncodingClass); auxiliaries=[]; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=[]; icdResult = Some icd}) let soSparkAnnotations = Some (sparkAnnotations lm td codec) createAcnFunction r deps lm codec t typeDefinition isValidFunc (fun us e acnArgs nestingScope p -> funcBody e acnArgs nestingScope p, us) (fun atc -> true) soSparkAnnotations [] us @@ -1212,7 +1191,7 @@ let createBitStringFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedF [{IcdRow.fieldName = fieldName; comments = comments; sPresent=sPresent;sType=(IcdPlainType (getASN1Name t)); sConstraint=None; minLengthInBits = o.acnMinSizeInBits ;maxLengthInBits=o.acnMaxSizeInBits;sUnits=t.unitsOfMeasure; rowType = IcdRowType.FieldRow; idxOffset = None}], [] let icd = {IcdArgAux.canBeEmbedded = true; baseAsn1Kind = (getASN1Name t); rowsFunc = icdFnc; commentsForTas=[]; scope="type"; name= None} - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (AcnBitStringEncodingType o.acnEncodingClass); auxiliaries=[]; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=[]; icdResult = Some icd}) let soSparkAnnotations = Some(sparkAnnotations lm td codec) createAcnFunction r deps lm codec t typeDefinition isValidFunc (fun us e acnArgs nestingScope p -> funcBody e acnArgs nestingScope p, us) (fun atc -> true) soSparkAnnotations [] us @@ -1290,15 +1269,10 @@ let createSequenceOfFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInserted nestingIx = nestingScope.nestingIx acnMaxOffset = nestingScope.acnOffset uperMaxOffset = nestingScope.uperOffset - typeInfo = { - uperMaxSizeBits = child.uperMaxSizeInBits - acnMaxSizeBits = child.acnMaxSizeInBits - typeKind = internalItem |> Option.bind (fun i -> i.typeEncodingKind) - } nestingScope = nestingScope cs = p encDec = internalItem |> Option.map (fun ii -> ii.funcBody) - elemDecodeFn = None // TODO: elemDecodeFn + elemDecodeFn = None ixVariable = i } let auxiliaries, callAux = lm.lg.generateSequenceOfLikeAuxiliaries r ACN (SqOf o) sqfProofGen codec @@ -1327,7 +1301,7 @@ let createSequenceOfFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInserted | true -> None | false -> let funcBody = varSize pp access td i "" o.minSize.acn o.maxSize.acn nSizeInBits child.acnMinSizeInBits nIntItemMaxSize 0I childInitExpr errCode.errCodeName absOffset remBits lvl ix offset introSnap callAux codec - Some ({AcnFuncBodyResult.funcBody = funcBody; errCodes = [errCode]; localVariables = lv@nStringLength; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=None; auxiliaries=auxiliaries; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBody; errCodes = [errCode]; localVariables = lv@nStringLength; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=auxiliaries; icdResult = Some icd}) | Some internalItem -> let childErrCodes = internalItem.errCodes @@ -1335,8 +1309,7 @@ let createSequenceOfFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInserted match o.isFixedSize with | true -> fixedSize pp td i internalItem.funcBody o.minSize.acn child.acnMinSizeInBits nIntItemMaxSize 0I childInitExpr callAux codec, nStringLength | false -> varSize pp access td i internalItem.funcBody o.minSize.acn o.maxSize.acn nSizeInBits child.acnMinSizeInBits nIntItemMaxSize 0I childInitExpr errCode.errCodeName absOffset remBits lvl ix offset introSnap callAux codec, nStringLength - let typeEncodingKind = internalItem.typeEncodingKind |> Option.map (fun tpe -> TypeEncodingKind.SequenceOfEncodingType (tpe, o.acnEncodingClass)) - Some ({AcnFuncBodyResult.funcBody = ret; errCodes = errCode::childErrCodes; localVariables = lv@(internalItem.localVariables@localVariables); bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=typeEncodingKind; auxiliaries=internalItem.auxiliaries @ auxiliaries; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = ret; errCodes = errCode::childErrCodes; localVariables = lv@(internalItem.localVariables@localVariables); bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=internalItem.auxiliaries @ auxiliaries; icdResult = Some icd}) | SZ_EC_ExternalField _ -> match internalItem with @@ -1356,8 +1329,7 @@ let createSequenceOfFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInserted match o.isFixedSize with | true -> oct_sqf_external_field_fix_size td pp access i internalItem.funcBody (if o.minSize.acn=0I then None else Some o.minSize.acn) o.maxSize.acn extField unsigned nAlignSize errCode.errCodeName o.child.acnMinSizeInBits o.child.acnMaxSizeInBits childInitExpr introSnap callAux codec | false -> external_field td pp access i internalItem.funcBody (if o.minSize.acn=0I then None else Some o.minSize.acn) o.maxSize.acn extField unsigned nAlignSize errCode.errCodeName o.child.acnMinSizeInBits o.child.acnMaxSizeInBits childInitExpr introSnap callAux codec - let typeEncodingKind = internalItem.typeEncodingKind |> Option.map (fun tpe -> TypeEncodingKind.SequenceOfEncodingType (tpe, o.acnEncodingClass)) - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCode::childErrCodes; localVariables = lv@localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=typeEncodingKind; auxiliaries=internalItem.auxiliaries @ auxiliaries; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCode::childErrCodes; localVariables = lv@localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=internalItem.auxiliaries @ auxiliaries; icdResult = Some icd}) | SZ_EC_TerminationPattern bitPattern -> match internalItem with @@ -1377,8 +1349,7 @@ let createSequenceOfFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInserted | Decode, true -> [IntegerLocalVariable ("checkBitPatternPresentResult", Some (lm.lg.intValueToString 0I (ASN1SCC_Int8 (-128I, 127I))))] | _ -> [] - let typeEncodingKind = internalItem.typeEncodingKind |> Option.map (fun tpe -> TypeEncodingKind.SequenceOfEncodingType (tpe, o.acnEncodingClass)) - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCode::childErrCodes; localVariables = lv2@lv@localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=None; typeEncodingKind=typeEncodingKind; auxiliaries=internalItem.auxiliaries; icdResult = Some icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCode::childErrCodes; localVariables = lv2@lv@localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=None; auxiliaries=internalItem.auxiliaries; icdResult = Some icd}) ret,ns let soSparkAnnotations = Some(sparkAnnotations lm td codec) createAcnFunction r deps lm codec t typeDefinition isValidFunc funcBody (fun atc -> true) soSparkAnnotations [] us @@ -1414,7 +1385,7 @@ let rec handleSingleUpdateDependency (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.Acn | Some prmUpdateStatement -> let updateFunc (child: AcnChild) (nestingScope: NestingScope) (vTarget : CallerScope) (pSrcRoot : CallerScope) = prmUpdateStatement.updateAcnChildFnc child nestingScope vTarget pSrcRoot - let icdComments = + let icdComments = let aaa = sprintf "reference determinant for %s " (acnPrm.id.AsString) [aaa] Some ({AcnChildUpdateResult.updateAcnChildFnc = updateFunc; icdComments=icdComments; errCodes=prmUpdateStatement.errCodes; testCaseFnc = prmUpdateStatement.testCaseFnc; localVariables=[]}), ns1 @@ -1437,7 +1408,7 @@ let rec handleSingleUpdateDependency (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.Acn let testCaseFnc (atc:AutomaticTestCase) : TestCaseValue option = atc.testCaseTypeIDsMap.TryFind d.asn1Type - let icdComments = + let icdComments = let aaa = sprintf "size determinant for %s " (d.asn1Type.AsString) [aaa] Some ({AcnChildUpdateResult.updateAcnChildFnc = updateFunc; icdComments=icdComments; errCodes=[]; testCaseFnc=testCaseFnc; localVariables=[]}), us @@ -1481,7 +1452,7 @@ let rec handleSingleUpdateDependency (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.Acn let testCaseFnc (atc:AutomaticTestCase) : TestCaseValue option = atc.testCaseTypeIDsMap.TryFind d.asn1Type let localVars = lm.lg.acn.getAcnDepSizeDeterminantLocVars sReqBytesForUperEncoding - let icdComments = + let icdComments = let aaa = sprintf "size determinant for %s " (d.asn1Type.AsString) [aaa] Some ({AcnChildUpdateResult.updateAcnChildFnc = updateFunc; icdComments=icdComments; errCodes=errCodes0; testCaseFnc=testCaseFnc; localVariables= localVariables0@localVars}), ns @@ -1496,7 +1467,7 @@ let rec handleSingleUpdateDependency (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.Acn | _ -> checkAccessPath checkPath updateStatement v (initExpr r lm m child.Type) let testCaseFnc (atc:AutomaticTestCase) : TestCaseValue option = atc.testCaseTypeIDsMap.TryFind d.asn1Type - let icdComments = + let icdComments = let aaa = sprintf "size determinant for %s " (d.asn1Type.AsString) [aaa] Some ({AcnChildUpdateResult.updateAcnChildFnc = updateFunc; icdComments=icdComments; errCodes=[]; testCaseFnc=testCaseFnc; localVariables=[]}), us @@ -1515,7 +1486,7 @@ let rec handleSingleUpdateDependency (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.Acn match atc.testCaseTypeIDsMap.TryFind(d.asn1Type) with | Some _ -> Some TcvComponentPresent | None -> Some TcvComponentAbsent - let icdComments = + let icdComments = let aaa = sprintf "Used as a presence determinant for %s " (d.asn1Type.AsString) [aaa] Some ({AcnChildUpdateResult.updateAcnChildFnc = updateFunc; icdComments=icdComments; errCodes=[]; testCaseFnc=testCaseFnc; localVariables=[]}), us @@ -1615,7 +1586,7 @@ let rec handleSingleUpdateDependency (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.Acn | _ -> checkAccessPath checkPath updateStatement2 v (initExpr r lm m child.Type) let testCaseFnc (atc:AutomaticTestCase) : TestCaseValue option = atc.testCaseTypeIDsMap.TryFind d.asn1Type - let icdComments = + let icdComments = let aaa = sprintf "Used as a presence determinant for %s " (chc.typeDef[C].asn1Name) [aaa] Some ({AcnChildUpdateResult.updateAcnChildFnc = updateFunc; icdComments=icdComments; errCodes=[] ; testCaseFnc=testCaseFnc; localVariables=[]}), us @@ -1729,7 +1700,6 @@ type private SequenceChildResult = { resultExpr: string option existVar: string option props: SequenceChildProps - typeKindEncoding: TypeEncodingKind option auxiliaries: string list icdResult : ((IcdRow list) * (IcdTypeAss list)) } with @@ -2016,7 +1986,7 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFi Some body, lv, [errCode], existVar, ns1a | _ -> None, [], [], None, ns1 - let childBody, childLvs, childErrs, childResultExpr, childTpeKind, auxiliaries, ns3 = + let childBody, childLvs, childErrs, childResultExpr, auxiliaries, ns3 = match childContentResult with | None -> // Copy-decoding expects to have a result expression (even if unused), so we pick the initExpression @@ -2028,8 +1998,8 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFi | Some Asn1AcnAst.AlwaysPresent -> let childBody (p: CallerScope) (existVar: string option): string = sequence_always_present_child (p.arg.joined lm.lg) (lm.lg.getAccess p.arg) childName None childResultExpr childTypeDef soSaveBitStrmPosStatement codec - Some childBody, [], [], childResultExpr, None, [], ns2 - | _ -> None, [], [], childResultExpr, None, [], ns2 + Some childBody, [], [], childResultExpr, [], ns2 + | _ -> None, [], [], childResultExpr, [], ns2 | Some childContent -> let childBody (p: CallerScope) (existVar: string option): string = match child.Optionality with @@ -2052,7 +2022,7 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFi match child.Optionality with | Some Asn1AcnAst.AlwaysAbsent -> [] | _ -> childContent.localVariables - Some childBody, lvs, childContent.errCodes, childContent.resultExpr, childContent.typeEncodingKind, childContent.auxiliaries, ns2 + Some childBody, lvs, childContent.errCodes, childContent.resultExpr, childContent.auxiliaries, ns2 let optAux, theCombinedBody = if presentWhenStmts.IsNone && childBody.IsNone then [], None @@ -2064,12 +2034,9 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFi optAux, Some theCombinedBody let stmts = {body = theCombinedBody; lvs = presentWhenLvs @ childLvs; errCodes = presentWhenErrs @ childErrs; icdComments = []} - let tpeKind = - if child.Optionality.IsSome then childTpeKind |> Option.map OptionEncodingType - else childTpeKind let props = {info=childInfo.toAsn1AcnAst; sel=childSel; uperMaxOffset=s.uperAccBits; acnMaxOffset=s.acnAccBits} let icdResult = icd_asn1_child child stmts.icdComments - let res = {stmts=[stmts]; resultExpr=childResultExpr; existVar=existVar; props=props; typeKindEncoding=tpeKind; auxiliaries=auxiliaries @ optAux; icdResult=icdResult} + let res = {stmts=[stmts]; resultExpr=childResultExpr; existVar=existVar; props=props; auxiliaries=auxiliaries @ optAux; icdResult=icdResult} let newAcc = {us=ns3; childIx=s.childIx + 1I; uperAccBits=s.uperAccBits + child.uperMaxSizeInBits; acnAccBits=s.acnAccBits + child.acnMaxSizeInBits} res, newAcc | AcnChild acnChild -> @@ -2088,34 +2055,34 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFi | Decode -> None, us //acn child encode/decode - let childEncDecStatement, childTpeKind, auxiliaries, ns2 = + let childEncDecStatement, auxiliaries, ns2 = let chFunc = acnChild.funcBody codec let childContentResult = chFunc [] childNestingScope childP match childContentResult with - | None -> None, None, [], ns1 + | None -> None, [], ns1 | Some childContent -> match codec with | Encode -> match acnChild.Type with | Asn1AcnAst.AcnNullType _ -> let childBody = Some (sequence_mandatory_child acnChild.c_name childContent.funcBody soSaveBitStrmPosStatement codec) - Some {body=childBody; lvs=childContent.localVariables; errCodes=childContent.errCodes;icdComments=[]}, childContent.typeEncodingKind, childContent.auxiliaries, ns1 + Some {body=childBody; lvs=childContent.localVariables; errCodes=childContent.errCodes;icdComments=[]}, childContent.auxiliaries, ns1 | _ -> let _errCodeName = ToC ("ERR_ACN" + (codec.suffix.ToUpper()) + "_" + ((acnChild.id.AcnAbsPath |> Seq.skip 1 |> Seq.StrJoin("-")).Replace("#","elm")) + "_UNINITIALIZED") let errCode, ns1a = getNextValidErrorCode ns1 _errCodeName None let childBody = Some (sequence_acn_child acnChild.c_name childContent.funcBody errCode.errCodeName soSaveBitStrmPosStatement codec) - Some {body=childBody; lvs=childContent.localVariables; errCodes=errCode::childContent.errCodes; icdComments=[]}, childContent.typeEncodingKind, childContent.auxiliaries, ns1a + Some {body=childBody; lvs=childContent.localVariables; errCodes=errCode::childContent.errCodes; icdComments=[]}, childContent.auxiliaries, ns1a | Decode -> let childBody = Some (sequence_mandatory_child acnChild.c_name childContent.funcBody soSaveBitStrmPosStatement codec) - Some {body=childBody; lvs=childContent.localVariables; errCodes=childContent.errCodes; icdComments=[]}, childContent.typeEncodingKind, childContent.auxiliaries, ns1 + Some {body=childBody; lvs=childContent.localVariables; errCodes=childContent.errCodes; icdComments=[]}, childContent.auxiliaries, ns1 let stmts = (updateStatement |> Option.toList)@(childEncDecStatement |> Option.toList) let icdComments = stmts |> List.collect(fun z -> z.icdComments) // Note: uperMaxSizeBits and uperAccBits here do not make sense since we are in ACN let props = {info=childInfo.toAsn1AcnAst; sel=childP.arg; uperMaxOffset=s.uperAccBits; acnMaxOffset=s.acnAccBits} let icdResult = icd_acn_child acnChild icdComments - let res = {stmts=stmts; resultExpr=None; existVar=None; props=props; typeKindEncoding=childTpeKind; auxiliaries=auxiliaries; icdResult=icdResult} + let res = {stmts=stmts; resultExpr=None; existVar=None; props=props; auxiliaries=auxiliaries; icdResult=icdResult} let newAcc = {us=ns2; childIx=s.childIx + 1I; uperAccBits=s.uperAccBits; acnAccBits=s.acnAccBits + acnChild.Type.acnMaxSizeInBits} res, newAcc // find acn inserted fields, which are not NULL types and which have no dependency. @@ -2156,7 +2123,6 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFi let childrenExistVar = childrenStatements00 |> List.choose(fun res -> res.existVar) let childrenResultExpr = childrenStatements00 |> List.choose(fun res -> res.resultExpr) let childrenErrCodes = childrenStatements0 |> List.collect(fun s -> s.errCodes) - let childrenTypeKindEncoding = childrenStatements00 |> List.map (fun s -> s.typeKindEncoding) let childrenAuxiliaries = childrenStatements00 |> List.collect (fun s -> s.auxiliaries) let resultExpr, seqBuild= @@ -2195,9 +2161,9 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFi match lm.lg.decodeEmptySeq (p.arg.joined lm.lg) with | None -> None, ns | Some decodeEmptySeq -> - Some ({AcnFuncBodyResult.funcBody = decodeEmptySeq; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalvars; bValIsUnReferenced= false; bBsIsUnReferenced=true; resultExpr=Some decodeEmptySeq; typeEncodingKind=Some (SequenceEncodingType childrenTypeKindEncoding); auxiliaries=childrenAuxiliaries @ aux; icdResult = Some icd}), ns + Some ({AcnFuncBodyResult.funcBody = decodeEmptySeq; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalvars; bValIsUnReferenced= false; bBsIsUnReferenced=true; resultExpr=Some decodeEmptySeq; auxiliaries=childrenAuxiliaries @ aux; icdResult = Some icd}), ns | Some ret -> - Some ({AcnFuncBodyResult.funcBody = ret; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalvars; bValIsUnReferenced= false; bBsIsUnReferenced=(o.acnMaxSizeInBits = 0I); resultExpr=resultExpr; typeEncodingKind=Some (SequenceEncodingType childrenTypeKindEncoding); auxiliaries=childrenAuxiliaries @ aux; icdResult = Some icd}), ns + Some ({AcnFuncBodyResult.funcBody = ret; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalvars; bValIsUnReferenced= false; bBsIsUnReferenced=(o.acnMaxSizeInBits = 0I); resultExpr=resultExpr; auxiliaries=childrenAuxiliaries @ aux; icdResult = Some icd}), ns | errChild::_ -> let determinantUsage = @@ -2428,15 +2394,14 @@ let createChoiceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFiel let conds = child.acnPresentWhenConditions |>List.map handPresenceCond let pp, _ = joinedOrAsIdentifier lm codec p Some (choiceChild_preWhen pp (lm.lg.getAccess p.arg) (lm.lg.presentWhenName (Some defOrRef) child) childContent_funcBody conds (idx=0) sChildName sChildTypeDef sChoiceTypeName sChildInitExpr codec) - [(childBody, childContent_localVariables, childContent_errCodes, childContentResult |> Option.bind (fun ch -> ch.typeEncodingKind), auxiliaries)], ns1 + [(childBody, childContent_localVariables, childContent_errCodes, auxiliaries)], ns1 let childrenStatements00, ns = children |> List.mapi (fun i x -> i,x) |> foldMap (fun us (i,x) -> handleChild us i x) us let childrenStatements0 = childrenStatements00 |> List.collect id - let childrenStatements = childrenStatements0 |> List.choose(fun (s,_,_,_,_) -> s) - let childrenLocalvars = childrenStatements0 |> List.collect(fun (_,s,_,_,_) -> s) - let childrenErrCodes = childrenStatements0 |> List.collect(fun (_,_,s,_,_) -> s) - let childrenTypeKindEncoding = childrenStatements0 |> List.map(fun (_,_,_,s, _) -> s) - let childrenAuxiliaries = childrenStatements0 |> List.collect(fun (_,_,_,_,a) -> a) + let childrenStatements = childrenStatements0 |> List.choose(fun (s,_,_,_) -> s) + let childrenLocalvars = childrenStatements0 |> List.collect(fun (_,s,_,_) -> s) + let childrenErrCodes = childrenStatements0 |> List.collect(fun (_,_,s,_) -> s) + let childrenAuxiliaries = childrenStatements0 |> List.collect(fun (_,_,_,a) -> a) let choiceContent, resultExpr = let pp, resultExpr = joinedOrAsIdentifier lm codec p @@ -2450,7 +2415,7 @@ let createChoiceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedFiel | CEC_presWhen -> choice_preWhen pp access childrenStatements errCode.errCodeName codec, resultExpr let choiceContent = lm.lg.generateChoiceProof r ACN t o choiceContent p.arg codec let aux = lm.lg.generateChoiceAuxiliaries r ACN t o nestingScope p.arg codec - Some ({AcnFuncBodyResult.funcBody = choiceContent; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalvars; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind = Some (ChoiceEncodingType childrenTypeKindEncoding); auxiliaries=childrenAuxiliaries@aux; icdResult = Some icd}), ns + Some ({AcnFuncBodyResult.funcBody = choiceContent; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalvars; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=childrenAuxiliaries@aux; icdResult = Some icd}), ns let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) @@ -2547,7 +2512,7 @@ let createReferenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedF toc, Some toc | _ -> str, None let funcBodyContent = callBaseTypeFunc lm pp baseFncName codec - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (ReferenceEncodingType baseTypeDefinitionName); auxiliaries=[]; icdResult = icd}), us + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=[]; icdResult = icd}), us let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) @@ -2617,7 +2582,7 @@ let createReferenceFunction (r:Asn1AcnAst.AstRoot) (deps:Asn1AcnAst.AcnInsertedF let fncBody = bit_string_containing_func pp baseFncName sReqBytesForUperEncoding sReqBitForUperEncoding nBits encOptions.minSize.acn encOptions.maxSize.acn false codec fncBody, [errCode],[] | SZ_EC_TerminationPattern nullVal , _ -> raise(SemanticError (loc, "Invalid type for parameter4")) - Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (ReferenceEncodingType baseTypeDefinitionName); auxiliaries=[]; icdResult = icd}) + Some ({AcnFuncBodyResult.funcBody = funcBodyContent; errCodes = errCodes; localVariables = localVariables; bValIsUnReferenced= false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=[]; icdResult = icd}) let soSparkAnnotations = Some(sparkAnnotations lm (typeDefinition.longTypedefName2 lm.lg.hasModules) codec) let a,b = createAcnFunction r deps lm codec t typeDefinition isValidFunc (fun us e acnArgs nestingScope p -> funcBody e acnArgs nestingScope p, us) (fun atc -> true) soSparkAnnotations [] us diff --git a/BackendAst/DAstUPer.fs b/BackendAst/DAstUPer.fs index cc5c71432..135b67ad0 100644 --- a/BackendAst/DAstUPer.fs +++ b/BackendAst/DAstUPer.fs @@ -206,7 +206,7 @@ let getIntfuncBodyByCons (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Commo let rootBody, _,_, intEncodingType = IntBod uperR true IntRootExt2 pp (getValueByConstraint uperR) cc rootBody errCode.errCodeName codec, false, false, intEncodingType | _ -> raise(BugErrorException "") - Some({UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=bValIsUnReferenced; bBsIsUnReferenced=bBsIsUnReferenced; resultExpr=resultExpr; typeEncodingKind=Some (Asn1IntegerEncodingType intEncodingType); auxiliaries = []}) + Some({UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=bValIsUnReferenced; bBsIsUnReferenced=bBsIsUnReferenced; resultExpr=resultExpr; auxiliaries = []}) let createIntegerFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:CommonTypes.Codec) (t:Asn1AcnAst.Asn1Type) (o:Asn1AcnAst.Integer) (typeDefinition:TypeDefinitionOrReference) (baseTypeUperFunc : UPerFunction option) (isValidFunc: IsValidFunction option) (us:State) = @@ -222,7 +222,7 @@ let createBooleanFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Comm let pp, resultExpr = adaptArgument lm codec p let Boolean = lm.uper.Boolean let funcBodyContent = Boolean pp errCode.errCodeName codec - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (AcnBooleanEncodingType None); auxiliaries = []} + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) createUperFunction r lm codec t typeDefinition baseTypeUperFunc isValidFunc (fun e ns p b -> Some (funcBody e ns p b)) soSparkAnnotations [] us @@ -242,7 +242,7 @@ let createRealFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:CommonT let castPp = castRPp lm codec (o.getClass r.args) pp let Real = lm.uper.Real let funcBodyContent = Real castPp sSuffix errCode.errCodeName codec - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (Asn1RealEncodingType cls); auxiliaries = []} + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) let annots = match ST.lang with @@ -259,7 +259,7 @@ let createObjectIdentifierFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) ( else lm.uper.ObjectIdentifier let funcBodyContent = ObjectIdentifier pp errCode.errCodeName codec - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some Placeholder; auxiliaries = []} // TODO: Placeholder + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) createUperFunction r lm codec t typeDefinition baseTypeUperFunc isValidFunc (fun e ns p b -> Some (funcBody e ns p b)) soSparkAnnotations [] us @@ -279,7 +279,7 @@ let createTimeTypeFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Co let pp, resultExpr = adaptArgumentPtr lm codec p let TimeType = lm.uper.Time let funcBodyContent = TimeType pp (getTimeSubTypeByClass o.timeClass) errCode.errCodeName codec - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some Placeholder; auxiliaries = []} // TODO: Placeholder + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) createUperFunction r lm codec t typeDefinition baseTypeUperFunc isValidFunc (fun e ns p b -> Some (funcBody e ns p b)) soSparkAnnotations [] us @@ -288,7 +288,7 @@ let createNullTypeFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Co let pp, _ = adaptArgument lm codec p match codec, lm.lg.decodingKind with | Decode, Copy -> - Some ({UPERFuncBodyResult.funcBody = lm.uper.Null_declare pp; errCodes = []; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=Some pp; typeEncodingKind=Some (AcnNullEncodingType None); auxiliaries = []}) + Some ({UPERFuncBodyResult.funcBody = lm.uper.Null_declare pp; errCodes = []; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=Some pp; auxiliaries = []}) | _ -> None let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) createUperFunction r lm codec t typeDefinition baseTypeUperFunc isValidFunc funcBody soSparkAnnotations [] us @@ -314,12 +314,12 @@ let createEnumeratedFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:C o.items |> List.mapi(fun i itm -> Enumerated_item pp (lm.lg.getNamedItemBackendName (Some typeDefinition) itm) (BigInteger i) nLastItemIndex codec) let nBits = (GetNumberOfBitsForNonNegativeInteger (nMax-nMin)) let funcBodyContent = Enumerated pp td items nMin nMax nBits errCode.errCodeName nLastItemIndex sFirstItemName codec - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (Asn1IntegerEncodingType (Some (FullyConstrained (nMin, nMax)))); auxiliaries = []} + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} | true -> let sEnumIndex = "nEnumIndex" let enumIndexVar = (Asn1SIntLocalVariable (sEnumIndex, None)) let funcBodyContent = Enumerated_no_switch pp td errCode.errCodeName sEnumIndex nLastItemIndex sFirstItemName codec - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = [enumIndexVar]; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (Asn1IntegerEncodingType (Some (FullyConstrained (nMin, nMax)))); auxiliaries = []} + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = [enumIndexVar]; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) createUperFunction r lm codec t typeDefinition baseTypeUperFunc isValidFunc (fun e ns p b -> Some (funcBody e ns p b)) soSparkAnnotations [] us @@ -462,11 +462,6 @@ let createIA5StringFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Co nestingIx = nestingScope.nestingIx acnMaxOffset = nestingScope.acnOffset uperMaxOffset = nestingScope.uperOffset - typeInfo = { - uperMaxSizeBits = nBits - acnMaxSizeBits = nBits - typeKind = Some (AcnStringEncodingType o.acnEncodingClass) // TODO: Check this - } nestingScope = nestingScope cs = p encDec = Some internalItem @@ -487,7 +482,7 @@ let createIA5StringFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Co let localVariables = localVariables |> List.addIf (lm.lg.uper.requires_IA5String_i || o.maxSize.uper<>o.minSize.uper) lv funcBodyContent, charIndex@localVariables - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (AcnStringEncodingType o.acnEncodingClass); auxiliaries = auxiliaries} + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = auxiliaries} let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) createUperFunction r lm codec t typeDefinition baseTypeUperFunc isValidFunc (fun e ns p b -> Some (funcBody e ns p b)) soSparkAnnotations [] us @@ -524,7 +519,7 @@ let createOctetStringFunction_funcBody (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros let localVariables = localVariables |> List.addIf (lm.lg.uper.requires_IA5String_i || (not isFixedSize)) (lv) funcBodyContent, localVariables - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (AcnOctetStringEncodingType o.acnEncodingClass); auxiliaries = []} + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} @@ -570,7 +565,7 @@ let createBitStringFunction_funcBody (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) let fragmentationLvars = fragmentationLvars |> List.addIf ((not isFixedSize) && lm.lg.uper.requires_sBLJ) (iVar) (funcBodyContent,fragmentationLvars) - {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (AcnBitStringEncodingType o.acnEncodingClass); auxiliaries = []} + {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} let createBitStringFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:CommonTypes.Codec) (t:Asn1AcnAst.Asn1Type) (o:Asn1AcnAst.BitString) (typeDefinition:TypeDefinitionOrReference) (baseTypeUperFunc : UPerFunction option) (isValidFunc: IsValidFunction option) (us:State) = @@ -624,15 +619,10 @@ let createSequenceOfFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:C nestingIx = nestingScope.nestingIx acnMaxOffset = nestingScope.acnOffset uperMaxOffset = nestingScope.uperOffset - typeInfo = { - uperMaxSizeBits = child.uperMaxSizeInBits - acnMaxSizeBits = child.acnMaxSizeInBits - typeKind = internalItem |> Option.bind (fun i -> i.typeEncodingKind) - } nestingScope = nestingScope cs = p encDec = internalItem |> Option.map (fun ii -> ii.funcBody) - elemDecodeFn = None // TODO: elemDecodeFn + elemDecodeFn = None ixVariable = i } let auxiliaries, callAux = lm.lg.generateSequenceOfLikeAuxiliaries r (if fromACN then ACN else UPER) (SqOf o) sqfProofGen codec @@ -650,10 +640,10 @@ let createSequenceOfFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:C | _ when o.maxSize.uper < 65536I && o.maxSize.uper=o.minSize.uper -> None | _ when o.maxSize.uper < 65536I && o.maxSize.uper<>o.minSize.uper -> let funcBody = varSize pp access td i "" o.minSize.uper o.maxSize.uper nSizeInBits child.uperMinSizeInBits nIntItemMaxSize 0I childInitExpr errCode.errCodeName absOffset remBits lvl ix offset introSnap callAux codec - Some ({UPERFuncBodyResult.funcBody = funcBody; errCodes = [errCode]; localVariables = lv@nStringLength; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=None; auxiliaries = auxiliaries}) + Some ({UPERFuncBodyResult.funcBody = funcBody; errCodes = [errCode]; localVariables = lv@nStringLength; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = auxiliaries}) | _ -> let funcBody, localVariables = handleFragmentation lm p codec errCode ii ( o.uperMaxSizeInBits) o.minSize.uper o.maxSize.uper "" nIntItemMaxSize false false - Some ({UPERFuncBodyResult.funcBody = funcBody; errCodes = [errCode]; localVariables = localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=None; auxiliaries = auxiliaries}) + Some ({UPERFuncBodyResult.funcBody = funcBody; errCodes = [errCode]; localVariables = localVariables; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = auxiliaries}) | Some internalItem -> let childErrCodes = internalItem.errCodes let internalItemBody = @@ -667,12 +657,11 @@ let createSequenceOfFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:C | _ when o.maxSize.uper < 65536I && o.maxSize.uper=o.minSize.uper -> fixedSize pp td i internalItemBody o.minSize.uper child.uperMinSizeInBits nIntItemMaxSize 0I childInitExpr callAux codec, nStringLength | _ when o.maxSize.uper < 65536I && o.maxSize.uper<>o.minSize.uper -> varSize pp access td i internalItemBody o.minSize.uper o.maxSize.uper nSizeInBits child.uperMinSizeInBits nIntItemMaxSize 0I childInitExpr errCode.errCodeName absOffset remBits lvl ix offset introSnap callAux codec, nStringLength | _ -> handleFragmentation lm p codec errCode ii ( o.uperMaxSizeInBits) o.minSize.uper o.maxSize.uper internalItemBody nIntItemMaxSize false false - let typeEncodingKind = internalItem.typeEncodingKind |> Option.map (fun tpe -> TypeEncodingKind.SequenceOfEncodingType (tpe, o.acnEncodingClass)) - Some ({UPERFuncBodyResult.funcBody = ret; errCodes = errCode::childErrCodes; localVariables = lv@(localVariables@internalItem.localVariables); bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=typeEncodingKind; auxiliaries=internalItem.auxiliaries@auxiliaries}) + Some ({UPERFuncBodyResult.funcBody = ret; errCodes = errCode::childErrCodes; localVariables = lv@(localVariables@internalItem.localVariables); bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=internalItem.auxiliaries@auxiliaries}) | Some baseFuncName -> let pp, resultExpr = adaptArgumentPtr lm codec p let funcBodyContent = callBaseTypeFunc lm pp baseFuncName codec - Some ({UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=None; auxiliaries = []}) + Some ({UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []}) let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) createUperFunction r lm codec t typeDefinition baseTypeUperFunc isValidFunc funcBody soSparkAnnotations [] us @@ -690,7 +679,6 @@ type private SequenceChildResult = { stmt: SequenceChildStmt option resultExpr: string option props: SequenceChildProps - typeEncodingKind: TypeEncodingKind option auxiliaries: string list } @@ -765,7 +753,7 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Com match codec, lm.lg.decodingKind with | Decode, Copy -> Some child.Type.initFunction.initExpression | _ -> None - {stmt=None; resultExpr=childResultExpr; props=props; typeEncodingKind=None; auxiliaries = []}, newAcc + {stmt=None; resultExpr=childResultExpr; props=props; auxiliaries = []}, newAcc | Some childContent -> let childBody, child_localVariables = match child.Optionality with @@ -795,7 +783,6 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Com } resultExpr = childContent.resultExpr props = props - typeEncodingKind = childContent.typeEncodingKind auxiliaries = childContent.auxiliaries }, newAcc @@ -819,7 +806,6 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Com let childrenLocalVars = childrenStatements0 |> List.collect(fun s -> s.lvs) let childrenErrCodes = childrenStatements0 |> List.collect(fun s -> s.errCodes) let childrenResultExpr = childrenStatements00 |> List.choose(fun s -> s.resultExpr) - let childrenTypeKindEncoding = childrenStatements00 |> List.map(fun s -> s.typeEncodingKind) let childrenAuxiliaries = childrenStatements00 |> List.collect(fun s -> s.auxiliaries) // If we are Decoding with Copy decoding kind, then all children `resultExpr` must be defined as well (i.e. we must have the same number of `resultExpr` as children) @@ -828,7 +814,7 @@ let createSequenceFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Com let seqContent = (childrenStatements@seqBuild) |> nestChildItems lm codec match seqContent with | None -> None - | Some ret -> Some ({UPERFuncBodyResult.funcBody = ret; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalVars; bValIsUnReferenced=false; bBsIsUnReferenced=(o.uperMaxSizeInBits = 0I); resultExpr=resultExpr; typeEncodingKind=Some (SequenceEncodingType childrenTypeKindEncoding); auxiliaries=childrenAuxiliaries}) + | Some ret -> Some ({UPERFuncBodyResult.funcBody = ret; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalVars; bValIsUnReferenced=false; bBsIsUnReferenced=(o.uperMaxSizeInBits = 0I); resultExpr=resultExpr; auxiliaries=childrenAuxiliaries}) let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) createUperFunction r lm codec t typeDefinition None isValidFunc funcBody soSparkAnnotations [] us @@ -855,7 +841,7 @@ let createChoiceFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Commo let acnSiblingMaxSize = children |> List.map (fun c -> c.chType.acnMaxSizeInBits) |> List.max let uperSiblingMaxSize = children |> List.map (fun c -> c.chType.uperMaxSizeInBits) |> List.max - let handleChild (nIndexSizeInBits: BigInteger) (i: int) (child: ChChildInfo): string * LocalVariable list * ErrorCode list * TypeEncodingKind option * string list = + let handleChild (nIndexSizeInBits: BigInteger) (i: int) (child: ChChildInfo): string * LocalVariable list * ErrorCode list * string list = let childNestingScope = {nestingScope with nestingLevel = nestingScope.nestingLevel + 1I @@ -890,29 +876,28 @@ let createChoiceFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:Commo | Sequence _ -> uper_a.decode_empty_sequence_emptySeq childp.arg.receiverId | _ -> lm.lg.createSingleLineComment "no encoding/decoding is required" | true -> lm.lg.createSingleLineComment "no encoding/decoding is required" - mk_choice_child childContent, [], [], None, [] + mk_choice_child childContent, [], [], [] | Some childContent -> - mk_choice_child childContent.funcBody, childContent.localVariables, childContent.errCodes, childContent.typeEncodingKind, childContent.auxiliaries + mk_choice_child childContent.funcBody, childContent.localVariables, childContent.errCodes, childContent.auxiliaries match baseFuncName with | None -> let nIndexSizeInBits = (GetNumberOfBitsForNonNegativeInteger (BigInteger (children.Length - 1))) let childrenContent3 = children |> List.mapi (handleChild nIndexSizeInBits) - let childrenContent = childrenContent3 |> List.map(fun (s,_,_,_,_) -> s) - let childrenLocalvars = childrenContent3 |> List.collect(fun (_,s,_,_,_) -> s) - let childrenErrCodes = childrenContent3 |> List.collect(fun (_,_,s,_,_) -> s) - let childrenTypeKindEncoding = childrenContent3 |> List.map(fun (_,_,_,s, _) -> s) - let childrenAuxiliaries = childrenContent3 |> List.collect(fun (_,_,_,_, a) -> a) + let childrenContent = childrenContent3 |> List.map(fun (s,_,_,_) -> s) + let childrenLocalvars = childrenContent3 |> List.collect(fun (_,s,_,_) -> s) + let childrenErrCodes = childrenContent3 |> List.collect(fun (_,_,s,_) -> s) + let childrenAuxiliaries = childrenContent3 |> List.collect(fun (_,_,_,a) -> a) let introSnap = nestingScope.nestingLevel = 0I let pp, resultExpr = joinedOrAsIdentifier lm codec p let ret = choice pp (lm.lg.getAccess p.arg) childrenContent (BigInteger (children.Length - 1)) sChoiceIndexName errCode.errCodeName td nIndexSizeInBits introSnap codec let ret = lm.lg.generateChoiceProof r ACN t o ret p.arg codec - Some ({UPERFuncBodyResult.funcBody = ret; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalvars; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (ChoiceEncodingType childrenTypeKindEncoding); auxiliaries=childrenAuxiliaries}) + Some ({UPERFuncBodyResult.funcBody = ret; errCodes = errCode::childrenErrCodes; localVariables = localVariables@childrenLocalvars; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=childrenAuxiliaries}) | Some baseFuncName -> let pp, resultExpr = adaptArgumentPtr lm codec p let funcBodyContent = callBaseTypeFunc lm pp baseFuncName codec let ret = lm.lg.generateChoiceProof r ACN t o funcBodyContent p.arg codec - Some ({UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=None; auxiliaries=[]}) + Some ({UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries=[]}) let soSparkAnnotations = Some(sparkAnnotations lm (lm.lg.getLongTypedefName typeDefinition) codec) @@ -939,7 +924,7 @@ let createReferenceFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:C toc, Some toc | _ -> str, None let funcBodyContent = callBaseTypeFunc lm pp baseFncName codec - Some {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (ReferenceEncodingType baseTypeDefinitionName); auxiliaries = []} + Some {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} | None -> None createUperFunction r lm codec t typeDefinition None isValidFunc funcBody soSparkAnnotations [] us | false -> @@ -965,6 +950,6 @@ let createReferenceFunction (r:Asn1AcnAst.AstRoot) (lm:LanguageMacros) (codec:C match opts.octOrBitStr with | ContainedInOctString -> octet_string_containing_func pp baseFncName sReqBytesForUperEncoding nBits opts.minSize.uper opts.maxSize.uper codec | ContainedInBitString -> bit_string_containing_func pp baseFncName sReqBytesForUperEncoding sReqBitForUperEncoding nBits opts.minSize.uper opts.maxSize.uper codec - Some {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; typeEncodingKind=Some (ReferenceEncodingType baseTypeDefinitionName); auxiliaries = []} + Some {UPERFuncBodyResult.funcBody = funcBodyContent; errCodes = [errCode]; localVariables = []; bValIsUnReferenced=false; bBsIsUnReferenced=false; resultExpr=resultExpr; auxiliaries = []} | None -> None createUperFunction r lm codec t typeDefinition None isValidFunc funcBody soSparkAnnotations [] us diff --git a/CommonTypes/FsUtils.fs b/CommonTypes/FsUtils.fs index a7e16caa7..cdc17d6e0 100644 --- a/CommonTypes/FsUtils.fs +++ b/CommonTypes/FsUtils.fs @@ -393,8 +393,8 @@ module List = match xs with | [] -> None | x :: xs -> - match f(x) with - | Some(b) -> Some(b) + match f x with + | Some b -> Some b | None -> tryFindMap f xs let foldBackWith (f: 'a -> 's -> 's) (init: 'a -> 's) (xs: 'a list): 's = diff --git a/FrontEndAst/DAst.fs b/FrontEndAst/DAst.fs index 482fb679c..12ae28b81 100644 --- a/FrontEndAst/DAst.fs +++ b/FrontEndAst/DAst.fs @@ -382,26 +382,8 @@ type Asn1IntegerEncodingType = | UnconstrainedMax of bigint | Unconstrained -type TypeEncodingKind = // TODO: Alignment??? - | Asn1IntegerEncodingType of Asn1IntegerEncodingType option // None if range min = max - | Asn1RealEncodingType of Asn1AcnAst.RealClass - | AcnIntegerEncodingType of AcnIntegerEncodingType - | AcnRealEncodingType of AcnRealEncodingType - | AcnBooleanEncodingType of AcnBooleanEncoding option - | AcnNullEncodingType of PATTERN_PROP_VALUE option - | AcnStringEncodingType of Asn1AcnAst.StringAcnEncodingClass - | AcnOctetStringEncodingType of Asn1AcnAst.SizeableAcnEncodingClass - | AcnBitStringEncodingType of Asn1AcnAst.SizeableAcnEncodingClass - | SequenceOfEncodingType of TypeEncodingKind * Asn1AcnAst.SizeableAcnEncodingClass - | SequenceEncodingType of TypeEncodingKind option list - | ChoiceEncodingType of TypeEncodingKind option list - | ReferenceEncodingType of string - | OptionEncodingType of TypeEncodingKind - | Placeholder - ///////////////////////////////////////////////////////////////////// - type NestingScope = { acnOuterMaxSize: bigint uperOuterMaxSize: bigint @@ -429,7 +411,6 @@ type UPERFuncBodyResult = { bValIsUnReferenced : bool bBsIsUnReferenced : bool resultExpr : string option - typeEncodingKind : TypeEncodingKind option auxiliaries : string list } type UPerFunction = { @@ -457,7 +438,6 @@ type AcnFuncBodyResult = { bValIsUnReferenced : bool bBsIsUnReferenced : bool resultExpr : string option - typeEncodingKind : TypeEncodingKind option auxiliaries : string list icdResult : IcdArgAux option } @@ -843,7 +823,6 @@ and Asn1Child = { isEqualBodyStats : CallerScope -> CallerScope -> (string*(LocalVariable list)) option Type : Asn1Type Optionality : Asn1AcnAst.Asn1Optionality option - // acnArgs : RelativePath list Comments : string array } with member this.toAsn1AcnAst: Asn1AcnAst.Asn1Child = @@ -854,7 +833,6 @@ and Asn1Child = { _ada_name = this._ada_name Type = this.Type.toAsn1AcnAst Optionality = this.Optionality - // acnArgs = this.acnArgs asn1Comments = this.Comments |> Array.toList acnComments = [] } diff --git a/FrontEndAst/Language.fs b/FrontEndAst/Language.fs index ed5ef871c..bcf4bf371 100644 --- a/FrontEndAst/Language.fs +++ b/FrontEndAst/Language.fs @@ -55,18 +55,6 @@ type UncheckedAccessKind = | FullAccess // unwrap all selection, including the last one | PartialAccess // unwrap all but the last selection -// TODO: Remove? -type TypeInfo = { - uperMaxSizeBits: bigint - acnMaxSizeBits: bigint - typeKind: TypeEncodingKind option -} with - member this.maxSize (enc: Asn1Encoding): bigint = - match enc with - | ACN -> this.acnMaxSizeBits - | UPER -> this.uperMaxSizeBits - | _ -> raise (BugErrorException $"Unexpected encoding: {enc}") - type SequenceChildProps = { info: Asn1AcnAst.SeqChildInfo sel: Selection @@ -100,9 +88,6 @@ type SequenceProofGen = { | UPER -> this.uperSiblingMaxSize | _ -> raise (BugErrorException $"Unexpected encoding: {enc}") - // member this.maxSize (enc: Asn1Encoding): BigInteger = - // this.children |> List.map (fun c -> c.typeInfo.maxSize enc) |> List.sum - member this.outerMaxSize (enc: Asn1Encoding): bigint = match enc with | ACN -> this.acnOuterMaxSize @@ -183,7 +168,6 @@ type SequenceOfLikeProofGen = { nestingIx: bigint acnMaxOffset: bigint uperMaxOffset: bigint - typeInfo: TypeInfo nestingScope: NestingScope cs: CallerScope encDec: string option diff --git a/StgScala/acn_scala.stg b/StgScala/acn_scala.stg index 872875aff..9726d7cda 100644 --- a/StgScala/acn_scala.stg +++ b/StgScala/acn_scala.stg @@ -554,7 +554,6 @@ locally { assert(codec.base.bitStream.bitIndex \<= oldCodec.base.bitStream.bitIndex + L) BitStream.validateOffsetBitsIneqLemma(oldCodec.base.bitStream, codec.base.bitStream, , L) check(codec.base.bitStream.bitIndex \<= codec_0_1.base.bitStream.bitIndex + L + L) - //check(codec.base.bitStream.bitIndex \<= codec__.base.bitStream.bitIndex + L + L) } } @@ -575,7 +574,6 @@ val

_nCount = locally { assert(codec.base.bitStream.bitIndex \<= oldCodec.base.bitStream.bitIndex + L) BitStream.validateOffsetBitsIneqLemma(oldCodec.base.bitStream, codec.base.bitStream, , L) check(codec.base.bitStream.bitIndex \<= codec_0_1.base.bitStream.bitIndex + L + L) - //check(codec.base.bitStream.bitIndex \<= codec__.base.bitStream.bitIndex + L + L) }

_nCount }