| package toml |
| |
| // tomlType represents any Go type that corresponds to a TOML type. |
| // While the first draft of the TOML spec has a simplistic type system that |
| // probably doesn't need this level of sophistication, we seem to be militating |
| // toward adding real composite types. |
| type tomlType interface { |
| typeString() string |
| } |
| |
| // typeEqual accepts any two types and returns true if they are equal. |
| func typeEqual(t1, t2 tomlType) bool { |
| if t1 == nil || t2 == nil { |
| return false |
| } |
| return t1.typeString() == t2.typeString() |
| } |
| |
| func typeIsHash(t tomlType) bool { |
| return typeEqual(t, tomlHash) || typeEqual(t, tomlArrayHash) |
| } |
| |
| type tomlBaseType string |
| |
| func (btype tomlBaseType) typeString() string { |
| return string(btype) |
| } |
| |
| func (btype tomlBaseType) String() string { |
| return btype.typeString() |
| } |
| |
| var ( |
| tomlInteger tomlBaseType = "Integer" |
| tomlFloat tomlBaseType = "Float" |
| tomlDatetime tomlBaseType = "Datetime" |
| tomlString tomlBaseType = "String" |
| tomlBool tomlBaseType = "Bool" |
| tomlArray tomlBaseType = "Array" |
| tomlHash tomlBaseType = "Hash" |
| tomlArrayHash tomlBaseType = "ArrayHash" |
| ) |
| |
| // typeOfPrimitive returns a tomlType of any primitive value in TOML. |
| // Primitive values are: Integer, Float, Datetime, String and Bool. |
| // |
| // Passing a lexer item other than the following will cause a BUG message |
| // to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime. |
| func (p *parser) typeOfPrimitive(lexItem item) tomlType { |
| switch lexItem.typ { |
| case itemInteger: |
| return tomlInteger |
| case itemFloat: |
| return tomlFloat |
| case itemDatetime: |
| return tomlDatetime |
| case itemString: |
| return tomlString |
| case itemMultilineString: |
| return tomlString |
| case itemRawString: |
| return tomlString |
| case itemRawMultilineString: |
| return tomlString |
| case itemBool: |
| return tomlBool |
| } |
| p.bug("Cannot infer primitive type of lex item '%s'.", lexItem) |
| panic("unreachable") |
| } |
| |
| // typeOfArray returns a tomlType for an array given a list of types of its |
| // values. |
| // |
| // In the current spec, if an array is homogeneous, then its type is always |
| // "Array". If the array is not homogeneous, an error is generated. |
| func (p *parser) typeOfArray(types []tomlType) tomlType { |
| // Empty arrays are cool. |
| if len(types) == 0 { |
| return tomlArray |
| } |
| |
| theType := types[0] |
| for _, t := range types[1:] { |
| if !typeEqual(theType, t) { |
| p.panicf("Array contains values of type '%s' and '%s', but "+ |
| "arrays must be homogeneous.", theType, t) |
| } |
| } |
| return tomlArray |
| } |