Skip to content

Commit

Permalink
added support for reading shift operand values
Browse files Browse the repository at this point in the history 
continued implementation of reading values from hex
  • Loading branch information
@asap2Go
asap2Go committed Dec 6, 2022
1 parent 9f9fa56 commit da5e5a5
Show file tree
Hide file tree
Showing 10 changed files with 265 additions and 105 deletions.
60 changes: 30 additions & 30 deletions a2l/record_layout.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -57,11 +57,11 @@ type RecordLayout struct {
SrcAddrZ srcAddrZ
SrcAddr4 srcAddr4
SrcAddr5 srcAddr5
ShiftOpX shiftOpX
ShiftOpY shiftOpY
ShiftOpZ shiftOpZ
ShiftOp4 shiftOp4
ShiftOp5 shiftOp5
ShiftOpX ShiftOpX
ShiftOpY ShiftOpY
ShiftOpZ ShiftOpZ
ShiftOp4 ShiftOp4
ShiftOp5 ShiftOp5
StaticRecordLayout staticRecordLayoutKeyword
StaticAddressOffsets staticAddressOffsetsKeyword
RelativePositions map[uint16]string
Expand Down Expand Up @@ -815,54 +815,54 @@ func (rl *RecordLayout) GetRecordLayoutRelativePositions() (map[uint16]string, e
order[rl.RipAddrW.Position] = "RipAddrW"
}

if rl.ShiftOp4.positionSet {
field, exists := order[rl.ShiftOp4.position]
if rl.ShiftOp4.PositionSet {
field, exists := order[rl.ShiftOp4.Position]
if exists {
err = errors.New("position set twice in RecordLayout " + rl.Name + " for " + field + " and ShiftOp4")
log.Err(err).Msg("recordLayout relative positions could not be determined")
return order, err
}
order[rl.ShiftOp4.position] = "ShiftOp4"
order[rl.ShiftOp4.Position] = "ShiftOp4"
}

if rl.ShiftOp5.positionSet {
field, exists := order[rl.ShiftOp5.position]
if rl.ShiftOp5.PositionSet {
field, exists := order[rl.ShiftOp5.Position]
if exists {
err = errors.New("position set twice in RecordLayout " + rl.Name + " for " + field + " and ShiftOp5")
log.Err(err).Msg("recordLayout relative positions could not be determined")
return order, err
}
order[rl.ShiftOp5.position] = "ShiftOp5"
order[rl.ShiftOp5.Position] = "ShiftOp5"
}

if rl.ShiftOpX.positionSet {
field, exists := order[rl.ShiftOpX.position]
if rl.ShiftOpX.PositionSet {
field, exists := order[rl.ShiftOpX.Position]
if exists {
err = errors.New("position set twice in RecordLayout " + rl.Name + " for " + field + " and ShiftOpX")
log.Err(err).Msg("recordLayout relative positions could not be determined")
return order, err
}
order[rl.ShiftOpX.position] = "ShiftOpX"
order[rl.ShiftOpX.Position] = "ShiftOpX"
}

if rl.ShiftOpY.positionSet {
field, exists := order[rl.ShiftOpY.position]
if rl.ShiftOpY.PositionSet {
field, exists := order[rl.ShiftOpY.Position]
if exists {
err = errors.New("position set twice in RecordLayout " + rl.Name + " for " + field + " and ShiftOpY")
log.Err(err).Msg("recordLayout relative positions could not be determined")
return order, err
}
order[rl.ShiftOpY.position] = "ShiftOpY"
order[rl.ShiftOpY.Position] = "ShiftOpY"
}

if rl.ShiftOpZ.positionSet {
field, exists := order[rl.ShiftOpZ.position]
if rl.ShiftOpZ.PositionSet {
field, exists := order[rl.ShiftOpZ.Position]
if exists {
err = errors.New("position set twice in RecordLayout " + rl.Name + " for " + field + " and ShiftOpZ")
log.Err(err).Msg("recordLayout relative positions could not be determined")
return order, err
}
order[rl.ShiftOpZ.position] = "ShiftOpZ"
order[rl.ShiftOpZ.Position] = "ShiftOpZ"
}

if rl.SrcAddr4.positionSet {
Expand Down Expand Up @@ -1168,40 +1168,40 @@ func (rl *RecordLayout) GetDatatypeByFieldName(name string) (DataTypeEnum, error
}
return rl.SrcAddr5.datatype, nil
case "ShiftOpX":
if !rl.ShiftOpX.datatypeSet {
if !rl.ShiftOpX.DatatypeSet {
err := errors.New("no datatype set for " + name + " in record layout " + rl.Name)
log.Err(err).Msg("could not get datatype")
return undefinedDatatype, err
}
return rl.ShiftOpX.datatype, nil
return rl.ShiftOpX.Datatype, nil
case "ShiftOpY":
if !rl.ShiftOpY.datatypeSet {
if !rl.ShiftOpY.DatatypeSet {
err := errors.New("no datatype set for " + name + " in record layout " + rl.Name)
log.Err(err).Msg("could not get datatype")
return undefinedDatatype, err
}
return rl.ShiftOpY.datatype, nil
return rl.ShiftOpY.Datatype, nil
case "ShiftOpZ":
if !rl.ShiftOpZ.datatypeSet {
if !rl.ShiftOpZ.DatatypeSet {
err := errors.New("no datatype set for " + name + " in record layout " + rl.Name)
log.Err(err).Msg("could not get datatype")
return undefinedDatatype, err
}
return rl.ShiftOpZ.datatype, nil
return rl.ShiftOpZ.Datatype, nil
case "ShiftOp4":
if !rl.ShiftOp4.datatypeSet {
if !rl.ShiftOp4.DatatypeSet {
err := errors.New("no datatype set for " + name + " in record layout " + rl.Name)
log.Err(err).Msg("could not get datatype")
return undefinedDatatype, err
}
return rl.ShiftOp4.datatype, nil
return rl.ShiftOp4.Datatype, nil
case "ShiftOp5":
if !rl.ShiftOp5.datatypeSet {
if !rl.ShiftOp5.DatatypeSet {
err := errors.New("no datatype set for " + name + " in record layout " + rl.Name)
log.Err(err).Msg("could not get datatype")
return undefinedDatatype, err
}
return rl.ShiftOp5.datatype, nil
return rl.ShiftOp5.Datatype, nil
default:
err := errors.New("no datatype set for " + name + " in record layout " + rl.Name)
log.Err(err).Msg("could not get datatype")
Expand Down
36 changes: 23 additions & 13 deletions a2l/shift_op_4.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,15 +7,25 @@ import (
"github.com/rs/zerolog/log"
)

type shiftOp4 struct {
position uint16
positionSet bool
datatype DataTypeEnum
datatypeSet bool
/*
ShiftOp4 is the shift operand in the deposit structure to compute the axis points for
fixed characteristic curves and fixed characteristic maps (see also keyword
FIX_AXIS_PAR).
The axis points distribution for fixed characteristic curves or fixed
characteristic maps is derived from the two 'offset' and 'shift' parameters as follows:
for i = { 1...numberofaxispts }
Xi = Offset + (i - 1)*2^Shift
*/
type ShiftOp4 struct {
Position uint16
PositionSet bool
Datatype DataTypeEnum
DatatypeSet bool
}

func parseShiftOp4(tok *tokenGenerator) (shiftOp4, error) {
so4 := shiftOp4{}
func parseShiftOp4(tok *tokenGenerator) (ShiftOp4, error) {
so4 := ShiftOp4{}
var err error
forLoop:
for {
Expand All @@ -28,23 +38,23 @@ forLoop:
err = errors.New("unexpected token " + tok.current())
log.Err(err).Msg("shiftOp4 could not be parsed")
break forLoop
} else if !so4.positionSet {
} else if !so4.PositionSet {
var buf uint64
buf, err = strconv.ParseUint(tok.current(), 10, 16)
if err != nil {
log.Err(err).Msg("shiftOp4 position could not be parsed")
break forLoop
}
so4.position = uint16(buf)
so4.positionSet = true
so4.Position = uint16(buf)
so4.PositionSet = true
log.Info().Msg("shiftOp4 position successfully parsed")
} else if !so4.datatypeSet {
so4.datatype, err = parseDataTypeEnum(tok)
} else if !so4.DatatypeSet {
so4.Datatype, err = parseDataTypeEnum(tok)
if err != nil {
log.Err(err).Msg("shiftOp4 datatype could not be parsed")
break forLoop
}
so4.datatypeSet = true
so4.DatatypeSet = true
log.Info().Msg("shiftOp4 datatype successfully parsed")
break forLoop
}
Expand Down
36 changes: 23 additions & 13 deletions a2l/shift_op_5.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,15 +7,25 @@ import (
"github.com/rs/zerolog/log"
)

type shiftOp5 struct {
position uint16
positionSet bool
datatype DataTypeEnum
datatypeSet bool
/*
ShiftOp5 is the shift operand in the deposit structure to compute the axis points for
fixed characteristic curves and fixed characteristic maps (see also keyword
FIX_AXIS_PAR).
The axis points distribution for fixed characteristic curves or fixed
characteristic maps is derived from the two 'offset' and 'shift' parameters as follows:
for i = { 1...numberofaxispts }
Xi = Offset + (i - 1)*2^Shift
*/
type ShiftOp5 struct {
Position uint16
PositionSet bool
Datatype DataTypeEnum
DatatypeSet bool
}

func parseShiftOp5(tok *tokenGenerator) (shiftOp5, error) {
so5 := shiftOp5{}
func parseShiftOp5(tok *tokenGenerator) (ShiftOp5, error) {
so5 := ShiftOp5{}
var err error
forLoop:
for {
Expand All @@ -28,23 +38,23 @@ forLoop:
err = errors.New("unexpected token " + tok.current())
log.Err(err).Msg("shiftOp5 could not be parsed")
break forLoop
} else if !so5.positionSet {
} else if !so5.PositionSet {
var buf uint64
buf, err = strconv.ParseUint(tok.current(), 10, 16)
if err != nil {
log.Err(err).Msg("shiftOp5 position could not be parsed")
break forLoop
}
so5.position = uint16(buf)
so5.positionSet = true
so5.Position = uint16(buf)
so5.PositionSet = true
log.Info().Msg("shiftOp5 position successfully parsed")
} else if !so5.datatypeSet {
so5.datatype, err = parseDataTypeEnum(tok)
} else if !so5.DatatypeSet {
so5.Datatype, err = parseDataTypeEnum(tok)
if err != nil {
log.Err(err).Msg("shiftOp5 datatype could not be parsed")
break forLoop
}
so5.datatypeSet = true
so5.DatatypeSet = true
log.Info().Msg("shiftOp5 datatype successfully parsed")
break forLoop
}
Expand Down
36 changes: 23 additions & 13 deletions a2l/shift_op_x.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,15 +7,25 @@ import (
"github.com/rs/zerolog/log"
)

type shiftOpX struct {
position uint16
positionSet bool
datatype DataTypeEnum
datatypeSet bool
/*
ShiftOpX is the shift operand in the deposit structure to compute the axis points for
fixed characteristic curves and fixed characteristic maps (see also keyword
FIX_AXIS_PAR).
The axis points distribution for fixed characteristic curves or fixed
characteristic maps is derived from the two 'offset' and 'shift' parameters as follows:
for i = { 1...numberofaxispts }
Xi = Offset + (i - 1)*2^Shift
*/
type ShiftOpX struct {
Position uint16
PositionSet bool
Datatype DataTypeEnum
DatatypeSet bool
}

func parseShiftOpX(tok *tokenGenerator) (shiftOpX, error) {
sox := shiftOpX{}
func parseShiftOpX(tok *tokenGenerator) (ShiftOpX, error) {
sox := ShiftOpX{}
var err error
forLoop:
for {
Expand All @@ -28,23 +38,23 @@ forLoop:
err = errors.New("unexpected token " + tok.current())
log.Err(err).Msg("shiftOpX could not be parsed")
break forLoop
} else if !sox.positionSet {
} else if !sox.PositionSet {
var buf uint64
buf, err = strconv.ParseUint(tok.current(), 10, 16)
if err != nil {
log.Err(err).Msg("shiftOpx position could not be parsed")
break forLoop
}
sox.position = uint16(buf)
sox.positionSet = true
sox.Position = uint16(buf)
sox.PositionSet = true
log.Info().Msg("shiftOpx position successfully parsed")
} else if !sox.datatypeSet {
sox.datatype, err = parseDataTypeEnum(tok)
} else if !sox.DatatypeSet {
sox.Datatype, err = parseDataTypeEnum(tok)
if err != nil {
log.Err(err).Msg("shiftOpx datatype could not be parsed")
break forLoop
}
sox.datatypeSet = true
sox.DatatypeSet = true
log.Info().Msg("shiftOpx datatype successfully parsed")
break forLoop
}
Expand Down
36 changes: 23 additions & 13 deletions a2l/shift_op_y.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,15 +7,25 @@ import (
"github.com/rs/zerolog/log"
)

type shiftOpY struct {
position uint16
positionSet bool
datatype DataTypeEnum
datatypeSet bool
/*
ShiftOpY is the shift operand in the deposit structure to compute the axis points for
fixed characteristic curves and fixed characteristic maps (see also keyword
FIX_AXIS_PAR).
The axis points distribution for fixed characteristic curves or fixed
characteristic maps is derived from the two 'offset' and 'shift' parameters as follows:
for i = { 1...numberofaxispts }
Xi = Offset + (i - 1)*2^Shift
*/
type ShiftOpY struct {
Position uint16
PositionSet bool
Datatype DataTypeEnum
DatatypeSet bool
}

func parseShiftOpY(tok *tokenGenerator) (shiftOpY, error) {
soy := shiftOpY{}
func parseShiftOpY(tok *tokenGenerator) (ShiftOpY, error) {
soy := ShiftOpY{}
var err error
forLoop:
for {
Expand All @@ -28,23 +38,23 @@ forLoop:
err = errors.New("unexpected token " + tok.current())
log.Err(err).Msg("shiftOpY could not be parsed")
break forLoop
} else if !soy.positionSet {
} else if !soy.PositionSet {
var buf uint64
buf, err = strconv.ParseUint(tok.current(), 10, 16)
if err != nil {
log.Err(err).Msg("shiftOpY position could not be parsed")
break forLoop
}
soy.position = uint16(buf)
soy.positionSet = true
soy.Position = uint16(buf)
soy.PositionSet = true
log.Info().Msg("shiftOpY position successfully parsed")
} else if !soy.datatypeSet {
soy.datatype, err = parseDataTypeEnum(tok)
} else if !soy.DatatypeSet {
soy.Datatype, err = parseDataTypeEnum(tok)
if err != nil {
log.Err(err).Msg("shiftOpY datatype could not be parsed")
break forLoop
}
soy.datatypeSet = true
soy.DatatypeSet = true
log.Info().Msg("shiftOpY datatype successfully parsed")
break forLoop
}
Expand Down
Loading

0 comments on commit da5e5a5

Please sign in to comment.