Skip to content

Commit b48e584

Browse files
monstermichlmonstermichl
committed
Do some renaming (#51)
1 parent be8bb3e commit b48e584

6 files changed

Lines changed: 53 additions & 53 deletions

File tree

‎converters/bash/converter.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -431,7 +431,7 @@ func (c *converter) SliceLen(name string, valueUsed bool) (string, error) {
431431
return c.VarEvaluation(helper, valueUsed, false)
432432
}
433433

434-
func (c *converter) StructDefinition(values []transpiler.StructValue, valueUsed bool) (string, error) {
434+
func (c *converter) StructInitialization(values []transpiler.StructValue, valueUsed bool) (string, error) {
435435
helper := c.nextDynamicHelperVar()
436436

437437
for _, value := range values {

‎converters/batch/converter.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -643,7 +643,7 @@ func (c *converter) SliceLen(name string, valueUsed bool) (string, error) {
643643
return c.VarEvaluation(helper, valueUsed, false)
644644
}
645645

646-
func (c *converter) StructDefinition(values []transpiler.StructValue, valueUsed bool) (string, error) {
646+
func (c *converter) StructInitialization(values []transpiler.StructValue, valueUsed bool) (string, error) {
647647
helper := c.nextDynamicHelperVar()
648648

649649
for _, value := range values {

‎parser/parser.go‎

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -387,12 +387,12 @@ func defaultVarValue(valueType ValueType, ctx context) (Expression, error) {
387387
case TypeKindString:
388388
return StringLiteral{}, nil
389389
case TypeKindStruct:
390-
structDeclaration, exists := elementaryDataType.(StructDeclaration)
390+
structDefinition, exists := elementaryDataType.(StructDefinition)
391391

392392
if exists {
393393
structValues := []StructValue{}
394394

395-
for _, field := range structDeclaration.Fields() {
395+
for _, field := range structDefinition.Fields() {
396396
defaultValue, err := defaultVarValue(field.ValueType(), ctx)
397397

398398
if err != nil {
@@ -406,7 +406,7 @@ func defaultVarValue(valueType ValueType, ctx context) (Expression, error) {
406406
value: defaultValue,
407407
})
408408
}
409-
return NewStructDefinition(valueType.Type(), structValues...), nil
409+
return NewStructInitialization(valueType.Type(), structValues...), nil
410410
}
411411
}
412412
} else {
@@ -1222,21 +1222,21 @@ func (p *Parser) evaluateValueType(ctx context) (ValueType, error) {
12221222
return evaluatedType, nil
12231223
}
12241224

1225-
func (p *Parser) evaluateStructDeclaration(name string, ctx context) (StructDeclaration, error) {
1225+
func (p *Parser) evaluateStructDefinition(name string, ctx context) (StructDefinition, error) {
12261226
structToken := p.eat()
12271227

12281228
if structToken.Type() != lexer.STRUCT {
1229-
return StructDeclaration{}, p.expectedKeywordError("struct", structToken)
1229+
return StructDefinition{}, p.expectedKeywordError("struct", structToken)
12301230
}
12311231
nextToken := p.eat()
12321232

12331233
if nextToken.Type() != lexer.OPENING_CURLY_BRACKET {
1234-
return StructDeclaration{}, p.expectedError(`"{"`, nextToken)
1234+
return StructDefinition{}, p.expectedError(`"{"`, nextToken)
12351235
}
12361236
nextToken = p.eat()
12371237

12381238
if nextToken.Type() != lexer.NEWLINE {
1239-
return StructDeclaration{}, p.expectedNewlineError(nextToken)
1239+
return StructDefinition{}, p.expectedNewlineError(nextToken)
12401240
}
12411241
fields := []StructField{}
12421242

@@ -1245,18 +1245,18 @@ func (p *Parser) evaluateStructDeclaration(name string, ctx context) (StructDecl
12451245
nameTokens, err := p.evaluateNames()
12461246

12471247
if err != nil {
1248-
return StructDeclaration{}, err
1248+
return StructDefinition{}, err
12491249
}
12501250
valueTypeToken := p.peek()
12511251
valueType, err := p.evaluateValueType(ctx)
12521252

12531253
if err != nil {
1254-
return StructDeclaration{}, err
1254+
return StructDefinition{}, err
12551255
}
12561256

12571257
// Don't allow nested structs for now.
12581258
if valueType.Type().Kind() == TypeKindStruct {
1259-
return StructDeclaration{}, p.atError("nested structs are not allowed", valueTypeToken)
1259+
return StructDefinition{}, p.atError("nested structs are not allowed", valueTypeToken)
12601260
}
12611261

12621262
for _, nameToken := range nameTokens {
@@ -1268,7 +1268,7 @@ func (p *Parser) evaluateStructDeclaration(name string, ctx context) (StructDecl
12681268
nextToken = p.eat()
12691269

12701270
if nextToken.Type() != lexer.NEWLINE {
1271-
return StructDeclaration{}, p.expectedNewlineError(nextToken)
1271+
return StructDefinition{}, p.expectedNewlineError(nextToken)
12721272
}
12731273
nextToken = p.peek()
12741274

@@ -1277,7 +1277,7 @@ func (p *Parser) evaluateStructDeclaration(name string, ctx context) (StructDecl
12771277
break
12781278
}
12791279
}
1280-
return NewStructDeclaration(name, fields), nil
1280+
return NewStructDefinition(name, fields), nil
12811281
}
12821282

12831283
func (p *Parser) evaluateTypeDeclaration(ctx context) (Statement, error) {
@@ -1310,12 +1310,12 @@ func (p *Parser) evaluateTypeDeclaration(ctx context) (Statement, error) {
13101310
if isAlias {
13111311
return nil, p.atError("struct alias is not supported", assignToken)
13121312
}
1313-
structDeclaration, err := p.evaluateStructDeclaration(name, ctx)
1313+
structDefinition, err := p.evaluateStructDefinition(name, ctx)
13141314

13151315
if err != nil {
13161316
return nil, err
13171317
}
1318-
valueType = NewValueType(structDeclaration, false)
1318+
valueType = NewValueType(structDefinition, false)
13191319
} else {
13201320
valueType, err = p.evaluateValueType(ctx)
13211321

@@ -2584,11 +2584,11 @@ func (p *Parser) evaluateStructEvaluation(importAlias string, ctx context) (Expr
25842584
if typeDeclarationKind != TypeKindStruct {
25852585
return nil, p.expectedError(fmt.Sprintf("%s but got %s", TypeKindStruct, typeDeclarationKind), identifierToken)
25862586
}
2587-
structDeclaration := typeDeclaration.(StructDeclaration)
2587+
structDefinition := typeDeclaration.(StructDefinition)
25882588

25892589
// Check field.
25902590
fieldName := fieldToken.Value()
2591-
foundField, err := structDeclaration.FindField(fieldName)
2591+
foundField, err := structDefinition.FindField(fieldName)
25922592

25932593
if err != nil {
25942594
return nil, p.atError(err.Error(), fieldToken)
@@ -3322,8 +3322,8 @@ func (p *Parser) evaluateStructInitialization(ctx context) (Expression, error) {
33223322
if err != nil {
33233323
return nil, err
33243324
}
3325-
structInitialization := intialization.(StructDefinition)
3326-
structDeclaration, valid := structValueType.Type().(StructDeclaration)
3325+
structInitialization := intialization.(StructInitialization)
3326+
structDefinition, valid := structValueType.Type().(StructDefinition)
33273327

33283328
if !valid || structValueType.IsSlice() {
33293329
return nil, p.expectedError(fmt.Sprintf("struct type but got %s", structValueType.String()), nextToken)
@@ -3334,7 +3334,7 @@ func (p *Parser) evaluateStructInitialization(ctx context) (Expression, error) {
33343334
if len(fieldName) == 0 {
33353335
return p.expectedError("field name", initValue.nameToken)
33363336
}
3337-
structField, err := structDeclaration.FindField(fieldName)
3337+
structField, err := structDefinition.FindField(fieldName)
33383338

33393339
if err != nil {
33403340
return err
@@ -3558,7 +3558,7 @@ func (p *Parser) evaluateStructAssignment(ctx context) (Statement, error) {
35583558
} else if namedValueBaseType.Kind() != TypeKindStruct {
35593559
return nil, p.expectedError(fmt.Sprintf("struct but variable is of type %s", namedValueBaseType.Kind()), nameToken)
35603560
}
3561-
structDeclaration := namedValueBaseType.(StructDeclaration)
3561+
structDefinition := namedValueBaseType.(StructDefinition)
35623562
nextToken := p.eat()
35633563

35643564
if nextToken.Type() != lexer.DOT {
@@ -3569,7 +3569,7 @@ func (p *Parser) evaluateStructAssignment(ctx context) (Statement, error) {
35693569
if nextToken.Type() != lexer.IDENTIFIER {
35703570
return nil, p.expectedError(`struct field`, nextToken)
35713571
}
3572-
structField, err := structDeclaration.FindField(nextToken.Value())
3572+
structField, err := structDefinition.FindField(nextToken.Value())
35733573

35743574
if err != nil {
35753575
return nil, p.atError(err.Error(), nextToken)

‎parser/struct.go‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -15,40 +15,40 @@ func (f StructField) ValueType() ValueType {
1515
return f.valueType
1616
}
1717

18-
type StructDeclaration struct {
18+
type StructDefinition struct {
1919
name string
2020
fields []StructField
2121
}
2222

23-
func NewStructDeclaration(name string, fields []StructField) StructDeclaration {
24-
return StructDeclaration{
23+
func NewStructDefinition(name string, fields []StructField) StructDefinition {
24+
return StructDefinition{
2525
name,
2626
fields,
2727
}
2828
}
2929

30-
func (d StructDeclaration) Fields() []StructField {
30+
func (d StructDefinition) Fields() []StructField {
3131
return d.fields
3232
}
3333

34-
func (d StructDeclaration) Name() string {
34+
func (d StructDefinition) Name() string {
3535
return d.name
3636
}
3737

38-
func (d StructDeclaration) IsAlias() bool {
38+
func (d StructDefinition) IsAlias() bool {
3939
return false
4040
}
4141

42-
func (d StructDeclaration) Kind() TypeKind {
42+
func (d StructDefinition) Kind() TypeKind {
4343
return TypeKindStruct
4444
}
4545

46-
func (d StructDeclaration) Base() Type {
46+
func (d StructDefinition) Base() Type {
4747
return nil
4848
}
4949

50-
func (d StructDeclaration) Equals(c Type) bool {
51-
compareType, isDeclaration := c.(StructDeclaration)
50+
func (d StructDefinition) Equals(c Type) bool {
51+
compareType, isDeclaration := c.(StructDefinition)
5252

5353
if !isDeclaration {
5454
return false
@@ -70,10 +70,10 @@ func (d StructDeclaration) Equals(c Type) bool {
7070
return true
7171
}
7272

73-
func (t StructDeclaration) ElementaryType() Type { return elementaryType(t) }
74-
func (t StructDeclaration) AliasedType() Type { return aliasedType(t) }
73+
func (t StructDefinition) ElementaryType() Type { return elementaryType(t) }
74+
func (t StructDefinition) AliasedType() Type { return aliasedType(t) }
7575

76-
func (d StructDeclaration) FindField(name string) (StructField, error) {
76+
func (d StructDefinition) FindField(name string) (StructField, error) {
7777
for _, field := range d.Fields() {
7878
if field.Name() == name {
7979
return field, nil
@@ -101,31 +101,31 @@ func (v StructValue) Value() Expression {
101101
return v.value
102102
}
103103

104-
type StructDefinition struct {
104+
type StructInitialization struct {
105105
t Type
106106
values []StructValue
107107
}
108108

109-
func NewStructDefinition(t Type, values ...StructValue) StructDefinition {
110-
return StructDefinition{
109+
func NewStructInitialization(t Type, values ...StructValue) StructInitialization {
110+
return StructInitialization{
111111
t,
112112
values,
113113
}
114114
}
115115

116-
func (d StructDefinition) StatementType() StatementType {
116+
func (d StructInitialization) StatementType() StatementType {
117117
return STATEMENT_TYPE_STRUCT_DEFINITION
118118
}
119119

120-
func (d StructDefinition) ValueType() ValueType {
120+
func (d StructInitialization) ValueType() ValueType {
121121
return NewValueType(d.t, false)
122122
}
123123

124-
func (d StructDefinition) IsConstant() bool {
124+
func (d StructInitialization) IsConstant() bool {
125125
return false
126126
}
127127

128-
func (d StructDefinition) Values() []StructValue {
128+
func (d StructInitialization) Values() []StructValue {
129129
return d.values
130130
}
131131

‎transpiler/converter.go‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,7 @@ type Converter interface {
7171
VarDefinition(name string, value string, global bool) error
7272
VarAssignment(name string, value string, global bool) error
7373
SliceAssignment(name string, index string, value string, defaultValue string, global bool) error
74-
StructAssignment(name string, field string, value string, dglobal bool) error
74+
StructAssignment(name string, field string, value string, global bool) error
7575
FuncStart(name string, params []string, returnTypes []parser.ValueType) error
7676
FuncEnd() error
7777
Return(values []ReturnValue) error
@@ -102,7 +102,7 @@ type Converter interface {
102102
SliceInstantiation(values []string, valueUsed bool) (string, error)
103103
SliceEvaluation(name string, index string, valueUsed bool) (string, error)
104104
SliceLen(name string, valueUsed bool) (string, error)
105-
StructDefinition(values []StructValue, valueUsed bool) (string, error)
105+
StructInitialization(values []StructValue, valueUsed bool) (string, error)
106106
StructEvaluation(name string, field string, valueUsed bool) (string, error)
107107
StringSubscript(value string, startIndex string, endIndex string, valueUsed bool) (string, error)
108108
StringLen(value string, valueUsed bool) (string, error)

‎transpiler/transpiler.go‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -80,14 +80,14 @@ func (t *transpiler) evaluateValueTypeDefaultValue(valueType parser.ValueType) (
8080
case parser.TypeKindString:
8181
defaultValue = conv.StringToString("")
8282
case parser.TypeKindStruct:
83-
structDeclaration, valid := valueType.Type().(parser.StructDeclaration)
83+
structDefinition, valid := valueType.Type().(parser.StructDefinition)
8484

8585
if !valid {
8686
return "", errors.New("struct declaration could not be evaluated")
8787
}
8888
values := []parser.StructValue{}
8989

90-
for _, field := range structDeclaration.Fields() {
90+
for _, field := range structDefinition.Fields() {
9191
fieldValueType := field.ValueType()
9292
defaultValueTemp, err := t.evaluateValueTypeDefaultValue(fieldValueType)
9393

@@ -98,8 +98,8 @@ func (t *transpiler) evaluateValueTypeDefaultValue(valueType parser.ValueType) (
9898
}
9999

100100
// Create helper struct definition.
101-
structDefinition := parser.NewStructDefinition(structDeclaration, values...)
102-
result, err := t.evaluateExpression(structDefinition, true)
101+
structInitialization := parser.NewStructInitialization(structDefinition, values...)
102+
result, err := t.evaluateExpression(structInitialization, true)
103103

104104
if err != nil {
105105
return "", err
@@ -682,7 +682,7 @@ func (t *transpiler) evaluateFunctionCall(functionCall parser.FunctionCall, valu
682682
param := params[i]
683683

684684
switch evaluationType := arg.ValueType().Type().(type) {
685-
case parser.StructDeclaration:
685+
case parser.StructDefinition:
686686
// If passed argument is a struct, the values need to be copied to avoid manipulation of the original.
687687
paramName := param.LayerName()
688688

@@ -772,7 +772,7 @@ func (t *transpiler) evaluateSliceInstantiation(instantiation parser.SliceInstan
772772
return newExpressionResult(s), nil
773773
}
774774

775-
func (t *transpiler) evaluateStructDefinition(definition parser.StructDefinition, valueUsed bool) (expressionResult, error) {
775+
func (t *transpiler) evaluateStructInitialization(definition parser.StructInitialization, valueUsed bool) (expressionResult, error) {
776776
values := []StructValue{}
777777

778778
for _, value := range definition.Values() {
@@ -786,7 +786,7 @@ func (t *transpiler) evaluateStructDefinition(definition parser.StructDefinition
786786
value: result.firstValue(),
787787
})
788788
}
789-
s, err := t.converter.StructDefinition(values, valueUsed)
789+
s, err := t.converter.StructInitialization(values, valueUsed)
790790

791791
if err != nil {
792792
return expressionResult{}, err
@@ -992,7 +992,7 @@ func (t *transpiler) evaluateExpression(expression parser.Expression, valueUsed
992992
case parser.STATEMENT_TYPE_SLICE_INSTANTIATION:
993993
return t.evaluateSliceInstantiation(expression.(parser.SliceInstantiation), valueUsed)
994994
case parser.STATEMENT_TYPE_STRUCT_DEFINITION:
995-
return t.evaluateStructDefinition(expression.(parser.StructDefinition), valueUsed)
995+
return t.evaluateStructInitialization(expression.(parser.StructInitialization), valueUsed)
996996
case parser.STATEMENT_TYPE_INPUT:
997997
return t.evaluateInput(expression.(parser.Input), valueUsed)
998998
case parser.STATEMENT_TYPE_COPY:

0 commit comments

Comments
 (0)