github.com/vcilabs/webrpc@v0.5.2-0.20201116131534-162e27b1b33b/schema/ridl/message_parser.go (about)

     1  package ridl
     2  
     3  func parserStateMessageFieldMetaDefinition(mn *MessageNode) parserState {
     4  	return func(p *parser) parserState {
     5  		// add to latest field
     6  		field := mn.fields[len(mn.fields)-1]
     7  
     8  		// + <tag.name> = value
     9  		_, err := p.match(tokenPlusSign, tokenWhitespace)
    10  		if err != nil {
    11  			return p.stateError(err)
    12  		}
    13  
    14  		// tag
    15  		left, err := p.expectMetadataKey()
    16  		if err != nil {
    17  			return p.stateError(err)
    18  		}
    19  
    20  		// =
    21  		_, err = p.match(tokenWhitespace, tokenEqual, tokenWhitespace)
    22  		if err != nil {
    23  			return p.stateError(err)
    24  		}
    25  
    26  		// - or value
    27  		right, err := p.expectMetadataValue()
    28  		if err != nil {
    29  			return p.stateError(err)
    30  		}
    31  
    32  		field.meta = append(field.meta, &DefinitionNode{
    33  			leftNode:  newTokenNode(left),
    34  			rightNode: newTokenNode(right),
    35  		})
    36  
    37  		return parserStateMessageFieldMeta(mn)
    38  	}
    39  }
    40  
    41  func parserStateMessageFieldMeta(mn *MessageNode) parserState {
    42  	return func(p *parser) parserState {
    43  
    44  		tok := p.cursor()
    45  
    46  		switch tok.tt {
    47  
    48  		case tokenNewLine, tokenWhitespace:
    49  			p.next()
    50  
    51  		case tokenHash:
    52  			p.continueUntilEOL()
    53  
    54  		case tokenPlusSign:
    55  			return parserStateMessageFieldMetaDefinition(mn)
    56  
    57  		default:
    58  			return parserStateMessageField(mn)
    59  
    60  		}
    61  
    62  		return parserStateMessageFieldMeta(mn)
    63  	}
    64  }
    65  
    66  func parserStateMessageFieldDefinition(mn *MessageNode) parserState {
    67  	return func(p *parser) parserState {
    68  		// - <name>: <type> [<# comment>][EOL]
    69  		matches, err := p.match(tokenDash, tokenWhitespace, tokenWord)
    70  		if err != nil {
    71  			return p.stateError(err)
    72  		}
    73  
    74  		field := &DefinitionNode{
    75  			leftNode: newTokenNode(matches[2]),
    76  		}
    77  
    78  		// ?
    79  		_, err = p.match(tokenQuestionMark)
    80  		if err == nil {
    81  			// got question mark
    82  			field.optional = true
    83  		}
    84  
    85  		// :
    86  		_, err = p.match(tokenColon, tokenWhitespace)
    87  		if err != nil {
    88  			return p.stateError(err)
    89  		}
    90  
    91  		typeToken, err := p.expectType()
    92  		if err != nil {
    93  			return p.stateError(err)
    94  		}
    95  		field.rightNode = newTokenNode(typeToken)
    96  
    97  		mn.fields = append(mn.fields, field)
    98  
    99  		return parserStateMessageFieldMeta(mn)
   100  	}
   101  }
   102  
   103  func parserStateMessageField(mn *MessageNode) parserState {
   104  	return func(p *parser) parserState {
   105  		tok := p.cursor()
   106  
   107  		switch tok.tt {
   108  
   109  		case tokenNewLine, tokenWhitespace:
   110  			p.next()
   111  
   112  		case tokenHash:
   113  			p.continueUntilEOL()
   114  
   115  		case tokenDash:
   116  			return parserStateMessageFieldDefinition(mn)
   117  
   118  		default:
   119  			p.emit(mn)
   120  			return parserDefaultState
   121  
   122  		}
   123  
   124  		return parserStateMessageField(mn)
   125  	}
   126  }
   127  
   128  func parserStateMessage(p *parser) parserState {
   129  	// message <name>
   130  	matches, err := p.match(tokenWord, tokenWhitespace, tokenWord)
   131  	if err != nil {
   132  		return p.stateError(err)
   133  	}
   134  
   135  	if matches[0].val != wordMessage {
   136  		return p.stateError(errUnexpectedToken)
   137  	}
   138  
   139  	return parserStateMessageField(&MessageNode{
   140  		name:   newTokenNode(matches[2]),
   141  		fields: []*DefinitionNode{},
   142  	})
   143  }