Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use Next method of parser Package

Best Gauge code snippet using parser.Next

expression.go

Source:expression.go

1package parser2import (3	"regexp"4	"github.com/robertkrimen/otto/ast"5	"github.com/robertkrimen/otto/file"6	"github.com/robertkrimen/otto/token"7)8func (self *_parser) parseIdentifier() *ast.Identifier {9	literal := self.literal10	idx := self.idx11	if self.mode&StoreComments != 0 {12		self.comments.MarkComments(ast.LEADING)13	}14	self.next()15	exp := &ast.Identifier{16		Name: literal,17		Idx:  idx,18	}19	if self.mode&StoreComments != 0 {20		self.comments.SetExpression(exp)21	}22	return exp23}24func (self *_parser) parsePrimaryExpression() ast.Expression {25	literal := self.literal26	idx := self.idx27	switch self.token {28	case token.IDENTIFIER:29		self.next()30		if len(literal) > 1 {31			tkn, strict := token.IsKeyword(literal)32			if tkn == token.KEYWORD {33				if !strict {34					self.error(idx, "Unexpected reserved word")35				}36			}37		}38		return &ast.Identifier{39			Name: literal,40			Idx:  idx,41		}42	case token.NULL:43		self.next()44		return &ast.NullLiteral{45			Idx:     idx,46			Literal: literal,47		}48	case token.BOOLEAN:49		self.next()50		value := false51		switch literal {52		case "true":53			value = true54		case "false":55			value = false56		default:57			self.error(idx, "Illegal boolean literal")58		}59		return &ast.BooleanLiteral{60			Idx:     idx,61			Literal: literal,62			Value:   value,63		}64	case token.STRING:65		self.next()66		value, err := parseStringLiteral(literal[1 : len(literal)-1])67		if err != nil {68			self.error(idx, err.Error())69		}70		return &ast.StringLiteral{71			Idx:     idx,72			Literal: literal,73			Value:   value,74		}75	case token.NUMBER:76		self.next()77		value, err := parseNumberLiteral(literal)78		if err != nil {79			self.error(idx, err.Error())80			value = 081		}82		return &ast.NumberLiteral{83			Idx:     idx,84			Literal: literal,85			Value:   value,86		}87	case token.SLASH, token.QUOTIENT_ASSIGN:88		return self.parseRegExpLiteral()89	case token.LEFT_BRACE:90		return self.parseObjectLiteral()91	case token.LEFT_BRACKET:92		return self.parseArrayLiteral()93	case token.LEFT_PARENTHESIS:94		self.expect(token.LEFT_PARENTHESIS)95		expression := self.parseExpression()96		if self.mode&StoreComments != 0 {97			self.comments.Unset()98		}99		self.expect(token.RIGHT_PARENTHESIS)100		return expression101	case token.THIS:102		self.next()103		return &ast.ThisExpression{104			Idx: idx,105		}106	case token.FUNCTION:107		return self.parseFunction(false)108	}109	self.errorUnexpectedToken(self.token)110	self.nextStatement()111	return &ast.BadExpression{From: idx, To: self.idx}112}113func (self *_parser) parseRegExpLiteral() *ast.RegExpLiteral {114	offset := self.chrOffset - 1 // Opening slash already gotten115	if self.token == token.QUOTIENT_ASSIGN {116		offset -= 1 // =117	}118	idx := self.idxOf(offset)119	pattern, err := self.scanString(offset)120	endOffset := self.chrOffset121	self.next()122	if err == nil {123		pattern = pattern[1 : len(pattern)-1]124	}125	flags := ""126	if self.token == token.IDENTIFIER { // gim127		flags = self.literal128		self.next()129		endOffset = self.chrOffset - 1130	}131	var value string132	// TODO 15.10133	{134		// Test during parsing that this is a valid regular expression135		// Sorry, (?=) and (?!) are invalid (for now)136		pattern, err := TransformRegExp(pattern)137		if err != nil {138			if pattern == "" || self.mode&IgnoreRegExpErrors == 0 {139				self.error(idx, "Invalid regular expression: %s", err.Error())140			}141		} else {142			_, err = regexp.Compile(pattern)143			if err != nil {144				// We should not get here, ParseRegExp should catch any errors145				self.error(idx, "Invalid regular expression: %s", err.Error()[22:]) // Skip redundant "parse regexp error"146			} else {147				value = pattern148			}149		}150	}151	literal := self.str[offset:endOffset]152	return &ast.RegExpLiteral{153		Idx:     idx,154		Literal: literal,155		Pattern: pattern,156		Flags:   flags,157		Value:   value,158	}159}160func (self *_parser) parseVariableDeclaration(declarationList *[]*ast.VariableExpression) ast.Expression {161	if self.token != token.IDENTIFIER {162		idx := self.expect(token.IDENTIFIER)163		self.nextStatement()164		return &ast.BadExpression{From: idx, To: self.idx}165	}166	literal := self.literal167	idx := self.idx168	self.next()169	node := &ast.VariableExpression{170		Name: literal,171		Idx:  idx,172	}173	if self.mode&StoreComments != 0 {174		self.comments.SetExpression(node)175	}176	if declarationList != nil {177		*declarationList = append(*declarationList, node)178	}179	if self.token == token.ASSIGN {180		if self.mode&StoreComments != 0 {181			self.comments.Unset()182		}183		self.next()184		node.Initializer = self.parseAssignmentExpression()185	}186	return node187}188func (self *_parser) parseVariableDeclarationList(var_ file.Idx) []ast.Expression {189	var declarationList []*ast.VariableExpression // Avoid bad expressions190	var list []ast.Expression191	for {192		if self.mode&StoreComments != 0 {193			self.comments.MarkComments(ast.LEADING)194		}195		decl := self.parseVariableDeclaration(&declarationList)196		list = append(list, decl)197		if self.token != token.COMMA {198			break199		}200		if self.mode&StoreComments != 0 {201			self.comments.Unset()202		}203		self.next()204	}205	self.scope.declare(&ast.VariableDeclaration{206		Var:  var_,207		List: declarationList,208	})209	return list210}211func (self *_parser) parseObjectPropertyKey() (string, string) {212	idx, tkn, literal := self.idx, self.token, self.literal213	value := ""214	if self.mode&StoreComments != 0 {215		self.comments.MarkComments(ast.KEY)216	}217	self.next()218	switch tkn {219	case token.IDENTIFIER:220		value = literal221	case token.NUMBER:222		var err error223		_, err = parseNumberLiteral(literal)224		if err != nil {225			self.error(idx, err.Error())226		} else {227			value = literal228		}229	case token.STRING:230		var err error231		value, err = parseStringLiteral(literal[1 : len(literal)-1])232		if err != nil {233			self.error(idx, err.Error())234		}235	default:236		// null, false, class, etc.237		if matchIdentifier.MatchString(literal) {238			value = literal239		}240	}241	return literal, value242}243func (self *_parser) parseObjectProperty() ast.Property {244	literal, value := self.parseObjectPropertyKey()245	if literal == "get" && self.token != token.COLON {246		idx := self.idx247		_, value := self.parseObjectPropertyKey()248		parameterList := self.parseFunctionParameterList()249		node := &ast.FunctionLiteral{250			Function:      idx,251			ParameterList: parameterList,252		}253		self.parseFunctionBlock(node)254		return ast.Property{255			Key:   value,256			Kind:  "get",257			Value: node,258		}259	} else if literal == "set" && self.token != token.COLON {260		idx := self.idx261		_, value := self.parseObjectPropertyKey()262		parameterList := self.parseFunctionParameterList()263		node := &ast.FunctionLiteral{264			Function:      idx,265			ParameterList: parameterList,266		}267		self.parseFunctionBlock(node)268		return ast.Property{269			Key:   value,270			Kind:  "set",271			Value: node,272		}273	}274	if self.mode&StoreComments != 0 {275		self.comments.MarkComments(ast.COLON)276	}277	self.expect(token.COLON)278	exp := ast.Property{279		Key:   value,280		Kind:  "value",281		Value: self.parseAssignmentExpression(),282	}283	if self.mode&StoreComments != 0 {284		self.comments.SetExpression(exp.Value)285	}286	return exp287}288func (self *_parser) parseObjectLiteral() ast.Expression {289	var value []ast.Property290	idx0 := self.expect(token.LEFT_BRACE)291	for self.token != token.RIGHT_BRACE && self.token != token.EOF {292		value = append(value, self.parseObjectProperty())293		if self.token == token.COMMA {294			if self.mode&StoreComments != 0 {295				self.comments.Unset()296			}297			self.next()298			continue299		}300	}301	if self.mode&StoreComments != 0 {302		self.comments.MarkComments(ast.FINAL)303	}304	idx1 := self.expect(token.RIGHT_BRACE)305	return &ast.ObjectLiteral{306		LeftBrace:  idx0,307		RightBrace: idx1,308		Value:      value,309	}310}311func (self *_parser) parseArrayLiteral() ast.Expression {312	idx0 := self.expect(token.LEFT_BRACKET)313	var value []ast.Expression314	for self.token != token.RIGHT_BRACKET && self.token != token.EOF {315		if self.token == token.COMMA {316			// This kind of comment requires a special empty expression node.317			empty := &ast.EmptyExpression{self.idx, self.idx}318			if self.mode&StoreComments != 0 {319				self.comments.SetExpression(empty)320				self.comments.Unset()321			}322			value = append(value, empty)323			self.next()324			continue325		}326		exp := self.parseAssignmentExpression()327		value = append(value, exp)328		if self.token != token.RIGHT_BRACKET {329			if self.mode&StoreComments != 0 {330				self.comments.Unset()331			}332			self.expect(token.COMMA)333		}334	}335	if self.mode&StoreComments != 0 {336		self.comments.MarkComments(ast.FINAL)337	}338	idx1 := self.expect(token.RIGHT_BRACKET)339	return &ast.ArrayLiteral{340		LeftBracket:  idx0,341		RightBracket: idx1,342		Value:        value,343	}344}345func (self *_parser) parseArgumentList() (argumentList []ast.Expression, idx0, idx1 file.Idx) {346	if self.mode&StoreComments != 0 {347		self.comments.Unset()348	}349	idx0 = self.expect(token.LEFT_PARENTHESIS)350	if self.token != token.RIGHT_PARENTHESIS {351		for {352			exp := self.parseAssignmentExpression()353			if self.mode&StoreComments != 0 {354				self.comments.SetExpression(exp)355			}356			argumentList = append(argumentList, exp)357			if self.token != token.COMMA {358				break359			}360			if self.mode&StoreComments != 0 {361				self.comments.Unset()362			}363			self.next()364		}365	}366	if self.mode&StoreComments != 0 {367		self.comments.Unset()368	}369	idx1 = self.expect(token.RIGHT_PARENTHESIS)370	return371}372func (self *_parser) parseCallExpression(left ast.Expression) ast.Expression {373	argumentList, idx0, idx1 := self.parseArgumentList()374	exp := &ast.CallExpression{375		Callee:           left,376		LeftParenthesis:  idx0,377		ArgumentList:     argumentList,378		RightParenthesis: idx1,379	}380	if self.mode&StoreComments != 0 {381		self.comments.SetExpression(exp)382	}383	return exp384}385func (self *_parser) parseDotMember(left ast.Expression) ast.Expression {386	period := self.expect(token.PERIOD)387	literal := self.literal388	idx := self.idx389	if !matchIdentifier.MatchString(literal) {390		self.expect(token.IDENTIFIER)391		self.nextStatement()392		return &ast.BadExpression{From: period, To: self.idx}393	}394	self.next()395	return &ast.DotExpression{396		Left: left,397		Identifier: &ast.Identifier{398			Idx:  idx,399			Name: literal,400		},401	}402}403func (self *_parser) parseBracketMember(left ast.Expression) ast.Expression {404	idx0 := self.expect(token.LEFT_BRACKET)405	member := self.parseExpression()406	idx1 := self.expect(token.RIGHT_BRACKET)407	return &ast.BracketExpression{408		LeftBracket:  idx0,409		Left:         left,410		Member:       member,411		RightBracket: idx1,412	}413}414func (self *_parser) parseNewExpression() ast.Expression {415	idx := self.expect(token.NEW)416	callee := self.parseLeftHandSideExpression()417	node := &ast.NewExpression{418		New:    idx,419		Callee: callee,420	}421	if self.token == token.LEFT_PARENTHESIS {422		argumentList, idx0, idx1 := self.parseArgumentList()423		node.ArgumentList = argumentList424		node.LeftParenthesis = idx0425		node.RightParenthesis = idx1426	}427	if self.mode&StoreComments != 0 {428		self.comments.SetExpression(node)429	}430	return node431}432func (self *_parser) parseLeftHandSideExpression() ast.Expression {433	var left ast.Expression434	if self.token == token.NEW {435		left = self.parseNewExpression()436	} else {437		if self.mode&StoreComments != 0 {438			self.comments.MarkComments(ast.LEADING)439			self.comments.MarkPrimary()440		}441		left = self.parsePrimaryExpression()442	}443	if self.mode&StoreComments != 0 {444		self.comments.SetExpression(left)445	}446	for {447		if self.token == token.PERIOD {448			left = self.parseDotMember(left)449		} else if self.token == token.LEFT_BRACKET {450			left = self.parseBracketMember(left)451		} else {452			break453		}454	}455	return left456}457func (self *_parser) parseLeftHandSideExpressionAllowCall() ast.Expression {458	allowIn := self.scope.allowIn459	self.scope.allowIn = true460	defer func() {461		self.scope.allowIn = allowIn462	}()463	var left ast.Expression464	if self.token == token.NEW {465		var newComments []*ast.Comment466		if self.mode&StoreComments != 0 {467			newComments = self.comments.FetchAll()468			self.comments.MarkComments(ast.LEADING)469			self.comments.MarkPrimary()470		}471		left = self.parseNewExpression()472		if self.mode&StoreComments != 0 {473			self.comments.CommentMap.AddComments(left, newComments, ast.LEADING)474		}475	} else {476		if self.mode&StoreComments != 0 {477			self.comments.MarkComments(ast.LEADING)478			self.comments.MarkPrimary()479		}480		left = self.parsePrimaryExpression()481	}482	if self.mode&StoreComments != 0 {483		self.comments.SetExpression(left)484	}485	for {486		if self.token == token.PERIOD {487			left = self.parseDotMember(left)488		} else if self.token == token.LEFT_BRACKET {489			left = self.parseBracketMember(left)490		} else if self.token == token.LEFT_PARENTHESIS {491			left = self.parseCallExpression(left)492		} else {493			break494		}495	}496	return left497}498func (self *_parser) parsePostfixExpression() ast.Expression {499	operand := self.parseLeftHandSideExpressionAllowCall()500	switch self.token {501	case token.INCREMENT, token.DECREMENT:502		// Make sure there is no line terminator here503		if self.implicitSemicolon {504			break505		}506		tkn := self.token507		idx := self.idx508		if self.mode&StoreComments != 0 {509			self.comments.Unset()510		}511		self.next()512		switch operand.(type) {513		case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:514		default:515			self.error(idx, "Invalid left-hand side in assignment")516			self.nextStatement()517			return &ast.BadExpression{From: idx, To: self.idx}518		}519		exp := &ast.UnaryExpression{520			Operator: tkn,521			Idx:      idx,522			Operand:  operand,523			Postfix:  true,524		}525		if self.mode&StoreComments != 0 {526			self.comments.SetExpression(exp)527		}528		return exp529	}530	return operand531}532func (self *_parser) parseUnaryExpression() ast.Expression {533	switch self.token {534	case token.PLUS, token.MINUS, token.NOT, token.BITWISE_NOT:535		fallthrough536	case token.DELETE, token.VOID, token.TYPEOF:537		tkn := self.token538		idx := self.idx539		if self.mode&StoreComments != 0 {540			self.comments.Unset()541		}542		self.next()543		return &ast.UnaryExpression{544			Operator: tkn,545			Idx:      idx,546			Operand:  self.parseUnaryExpression(),547		}548	case token.INCREMENT, token.DECREMENT:549		tkn := self.token550		idx := self.idx551		if self.mode&StoreComments != 0 {552			self.comments.Unset()553		}554		self.next()555		operand := self.parseUnaryExpression()556		switch operand.(type) {557		case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:558		default:559			self.error(idx, "Invalid left-hand side in assignment")560			self.nextStatement()561			return &ast.BadExpression{From: idx, To: self.idx}562		}563		return &ast.UnaryExpression{564			Operator: tkn,565			Idx:      idx,566			Operand:  operand,567		}568	}569	return self.parsePostfixExpression()570}571func (self *_parser) parseMultiplicativeExpression() ast.Expression {572	next := self.parseUnaryExpression573	left := next()574	for self.token == token.MULTIPLY || self.token == token.SLASH ||575		self.token == token.REMAINDER {576		tkn := self.token577		if self.mode&StoreComments != 0 {578			self.comments.Unset()579		}580		self.next()581		left = &ast.BinaryExpression{582			Operator: tkn,583			Left:     left,584			Right:    next(),585		}586	}587	return left588}589func (self *_parser) parseAdditiveExpression() ast.Expression {590	next := self.parseMultiplicativeExpression591	left := next()592	for self.token == token.PLUS || self.token == token.MINUS {593		tkn := self.token594		if self.mode&StoreComments != 0 {595			self.comments.Unset()596		}597		self.next()598		left = &ast.BinaryExpression{599			Operator: tkn,600			Left:     left,601			Right:    next(),602		}603	}604	return left605}606func (self *_parser) parseShiftExpression() ast.Expression {607	next := self.parseAdditiveExpression608	left := next()609	for self.token == token.SHIFT_LEFT || self.token == token.SHIFT_RIGHT ||610		self.token == token.UNSIGNED_SHIFT_RIGHT {611		tkn := self.token612		if self.mode&StoreComments != 0 {613			self.comments.Unset()614		}615		self.next()616		left = &ast.BinaryExpression{617			Operator: tkn,618			Left:     left,619			Right:    next(),620		}621	}622	return left623}624func (self *_parser) parseRelationalExpression() ast.Expression {625	next := self.parseShiftExpression626	left := next()627	allowIn := self.scope.allowIn628	self.scope.allowIn = true629	defer func() {630		self.scope.allowIn = allowIn631	}()632	switch self.token {633	case token.LESS, token.LESS_OR_EQUAL, token.GREATER, token.GREATER_OR_EQUAL:634		tkn := self.token635		if self.mode&StoreComments != 0 {636			self.comments.Unset()637		}638		self.next()639		exp := &ast.BinaryExpression{640			Operator:   tkn,641			Left:       left,642			Right:      self.parseRelationalExpression(),643			Comparison: true,644		}645		return exp646	case token.INSTANCEOF:647		tkn := self.token648		if self.mode&StoreComments != 0 {649			self.comments.Unset()650		}651		self.next()652		exp := &ast.BinaryExpression{653			Operator: tkn,654			Left:     left,655			Right:    self.parseRelationalExpression(),656		}657		return exp658	case token.IN:659		if !allowIn {660			return left661		}662		tkn := self.token663		if self.mode&StoreComments != 0 {664			self.comments.Unset()665		}666		self.next()667		exp := &ast.BinaryExpression{668			Operator: tkn,669			Left:     left,670			Right:    self.parseRelationalExpression(),671		}672		return exp673	}674	return left675}676func (self *_parser) parseEqualityExpression() ast.Expression {677	next := self.parseRelationalExpression678	left := next()679	for self.token == token.EQUAL || self.token == token.NOT_EQUAL ||680		self.token == token.STRICT_EQUAL || self.token == token.STRICT_NOT_EQUAL {681		tkn := self.token682		if self.mode&StoreComments != 0 {683			self.comments.Unset()684		}685		self.next()686		left = &ast.BinaryExpression{687			Operator:   tkn,688			Left:       left,689			Right:      next(),690			Comparison: true,691		}692	}693	return left694}695func (self *_parser) parseBitwiseAndExpression() ast.Expression {696	next := self.parseEqualityExpression697	left := next()698	for self.token == token.AND {699		if self.mode&StoreComments != 0 {700			self.comments.Unset()701		}702		tkn := self.token703		self.next()704		left = &ast.BinaryExpression{705			Operator: tkn,706			Left:     left,707			Right:    next(),708		}709	}710	return left711}712func (self *_parser) parseBitwiseExclusiveOrExpression() ast.Expression {713	next := self.parseBitwiseAndExpression714	left := next()715	for self.token == token.EXCLUSIVE_OR {716		if self.mode&StoreComments != 0 {717			self.comments.Unset()718		}719		tkn := self.token720		self.next()721		left = &ast.BinaryExpression{722			Operator: tkn,723			Left:     left,724			Right:    next(),725		}726	}727	return left728}729func (self *_parser) parseBitwiseOrExpression() ast.Expression {730	next := self.parseBitwiseExclusiveOrExpression731	left := next()732	for self.token == token.OR {733		if self.mode&StoreComments != 0 {734			self.comments.Unset()735		}736		tkn := self.token737		self.next()738		left = &ast.BinaryExpression{739			Operator: tkn,740			Left:     left,741			Right:    next(),742		}743	}744	return left745}746func (self *_parser) parseLogicalAndExpression() ast.Expression {747	next := self.parseBitwiseOrExpression748	left := next()749	for self.token == token.LOGICAL_AND {750		if self.mode&StoreComments != 0 {751			self.comments.Unset()752		}753		tkn := self.token754		self.next()755		left = &ast.BinaryExpression{756			Operator: tkn,757			Left:     left,758			Right:    next(),759		}760	}761	return left762}763func (self *_parser) parseLogicalOrExpression() ast.Expression {764	next := self.parseLogicalAndExpression765	left := next()766	for self.token == token.LOGICAL_OR {767		if self.mode&StoreComments != 0 {768			self.comments.Unset()769		}770		tkn := self.token771		self.next()772		left = &ast.BinaryExpression{773			Operator: tkn,774			Left:     left,775			Right:    next(),776		}777	}778	return left779}780func (self *_parser) parseConditionlExpression() ast.Expression {781	left := self.parseLogicalOrExpression()782	if self.token == token.QUESTION_MARK {783		if self.mode&StoreComments != 0 {784			self.comments.Unset()785		}786		self.next()787		consequent := self.parseAssignmentExpression()788		if self.mode&StoreComments != 0 {789			self.comments.Unset()790		}791		self.expect(token.COLON)792		exp := &ast.ConditionalExpression{793			Test:       left,794			Consequent: consequent,795			Alternate:  self.parseAssignmentExpression(),796		}797		return exp798	}799	return left800}801func (self *_parser) parseAssignmentExpression() ast.Expression {802	left := self.parseConditionlExpression()803	var operator token.Token804	switch self.token {805	case token.ASSIGN:806		operator = self.token807	case token.ADD_ASSIGN:808		operator = token.PLUS809	case token.SUBTRACT_ASSIGN:810		operator = token.MINUS811	case token.MULTIPLY_ASSIGN:812		operator = token.MULTIPLY813	case token.QUOTIENT_ASSIGN:814		operator = token.SLASH815	case token.REMAINDER_ASSIGN:816		operator = token.REMAINDER817	case token.AND_ASSIGN:818		operator = token.AND819	case token.AND_NOT_ASSIGN:820		operator = token.AND_NOT821	case token.OR_ASSIGN:822		operator = token.OR823	case token.EXCLUSIVE_OR_ASSIGN:824		operator = token.EXCLUSIVE_OR825	case token.SHIFT_LEFT_ASSIGN:826		operator = token.SHIFT_LEFT827	case token.SHIFT_RIGHT_ASSIGN:828		operator = token.SHIFT_RIGHT829	case token.UNSIGNED_SHIFT_RIGHT_ASSIGN:830		operator = token.UNSIGNED_SHIFT_RIGHT831	}832	if operator != 0 {833		idx := self.idx834		if self.mode&StoreComments != 0 {835			self.comments.Unset()836		}837		self.next()838		switch left.(type) {839		case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:840		default:841			self.error(left.Idx0(), "Invalid left-hand side in assignment")842			self.nextStatement()843			return &ast.BadExpression{From: idx, To: self.idx}844		}845		exp := &ast.AssignExpression{846			Left:     left,847			Operator: operator,848			Right:    self.parseAssignmentExpression(),849		}850		if self.mode&StoreComments != 0 {851			self.comments.SetExpression(exp)852		}853		return exp854	}855	return left856}857func (self *_parser) parseExpression() ast.Expression {858	next := self.parseAssignmentExpression859	left := next()860	if self.token == token.COMMA {861		sequence := []ast.Expression{left}862		for {863			if self.token != token.COMMA {864				break865			}866			self.next()867			sequence = append(sequence, next())868		}869		return &ast.SequenceExpression{870			Sequence: sequence,871		}872	}873	return left874}...

parser.go

Source:parser.go

...49	p.errors = append(p.errors, msg)50}51func (p *Parser) nextToken() {52	p.curToken = p.peekToken53	p.peekToken = p.l.NextToken()54}55func (p *Parser) ParseProgram() *ast.Program {56	program := &ast.Program{}57	program.Statements = []ast.Statement{}58	for p.curToken.Type != token.EOF {59		stmt := p.parseStatement()60		if stmt != nil {61			program.Statements = append(program.Statements, stmt)62		}63		p.nextToken()64	}65	return program66}67func (p *Parser) parseStatement() ast.Statement {...

Using AI Code Generation

1import (2func main() {3	doc, err := html.Parse(os.Stdin)4	if err != nil {5		fmt.Fprintf(os.Stderr, "findlinks1: %v6		os.Exit(1)7	}8	for _, link := range visit(nil, doc) {9		fmt.Println(link)10	}11}12func visit(links []string, n *html.Node) []string {13	if n.Type == html.ElementNode && n.Data == "a" {14		for _, a := range n.Attr {15			if a.Key == "href" {16				links = append(links, a.Val)17			}18		}19	}20	for c := n.FirstChild; c != nil; c = c.NextSibling {21		links = visit(links, c)22	}23}24import (25func main() {26	doc, err := html.Parse(os.Stdin)27	if err != nil {28		fmt.Fprintf(os.Stderr, "findlinks2: %v29		os.Exit(1)30	}31	for _, link := range visit(nil, doc) {32		fmt.Println(link)33	}34}35func visit(links []string, n *html.Node) []string {36	if n.Type == html.ElementNode && n.Data == "a" {37		for _, a := range n.Attr {38			if a.Key == "href" {39				links = append(links, a.Val)40			}41		}42	}43	links = traverse(links, n.FirstChild)44}45func traverse(links []string, n *html.Node) []string {46	if n == nil {47	}48	links = visit(links, n)49	links = traverse(links, n.NextSibling)50}51import (52func main() {53	doc, err := html.Parse(os.Stdin)54	if err != nil {55		fmt.Fprintf(os.Stderr, "findlinks3: %v56		os.Exit(1)57	}58	for _, link := range visit(nil, doc

Using AI Code Generation

1import (2type Person struct {3}4func main() {5    v := &Person{Name: "none", Age: 0}6    dec := xml.NewDecoder(os.Stdin)7    for {8        t, _ := dec.Token()9        if t == nil {10        }11        switch se := t.(type) {12            if se.Name.Local == "name" {13                if err := dec.DecodeElement(&v.Name, &se); err != nil {14                    fmt.Println(err)15                }16            }17            if se.Name.Local == "age" {18                if err := dec.DecodeElement(&v.Age, &se); err != nil {19                    fmt.Println(err)20                }21            }22            if se.Name.Local == "email" {23                if err := dec.DecodeElement(&email, &se); err != nil {24                    fmt.Println(err)25                }26                v.Emails = append(v.Emails, email)27            }28        }29    }30    fmt.Println(v)31}32&{person none 30 [

Using AI Code Generation

1import (2func main() {3    if err != nil {4        fmt.Println(err)5    }6    doc.Find(".mw-headline").Each(func(i int, s *goquery.Selection) {7        fmt.Println(s.Text())8    })9}

Using AI Code Generation

1import (2func main() {3    if err != nil {4        fmt.Println(err)5    }6    defer resp.Body.Close()7    z := html.NewTokenizer(resp.Body)8    for {9        tt := z.Next()10        switch tt {11            t := z.Token()12            fmt.Printf("%v13            t := z.Token()14            fmt.Printf("%v15        }16    }17}

Using AI Code Generation

1import (2func main() {3    import "fmt"4    func main() {5        fmt.Println("Hello, 世界")6    }`7    f, err := parser.ParseFile(fset, "hello.go", src, parser.ImportsOnly)8    if err != nil {9        fmt.Println(err)10    }11    for _, s := range f.Imports {12        fmt.Println(s.Path.Value)13    }14}15import (16func main() {17    import "fmt"18    func main() {19        fmt.Println("Hello, 世界")20    }`21    f, err := parser.ParseExpr(src)22    if err != nil {23        fmt.Println(err)24    }25    fmt.Println(f)26}27import (28func main() {29    import "fmt"30    func main() {31        fmt.Println("Hello, 世界")32    }`33    f, err := parser.ParseExprFrom(fset, "hello.go", src, 0)34    if err != nil {

Using AI Code Generation

1import (2func main() {3    p := filepath.NewParser()4    p.Parse("C:\\Users\\User\\Desktop\\Golang\\1.go")5    for p.Next() {6        fmt.Println(p.Path())7    }8}9import (10func main() {11    fmt.Println(filepath.Split("C:\\Users\\User\\Desktop\\Golang\\1.go"))12    fmt.Println(filepath.Split("C:\\Users\\User\\Desktop\\Golang"))13}14import (15func main() {16    fmt.Println(filepath.SplitList("C:\\Users\\User\\Desktop\\Golang\\1.go"))17    fmt.Println(filepath.SplitList("C:\\Users\\User\\Desktop\\Golang"))18}19import (20func main() {21    fmt.Println(filepath.Split("C:\\Users\\User\\Desktop\\Golang\\1.go"))22    fmt.Println(filepath.Split("C:\\Users\\User\\Desktop\\Golang"))23}24import (25func main() {26    fmt.Println(filepath.ToSlash("C:\\Users\\User\\Desktop\\Golang\\1.go"))27    fmt.Println(filepath.ToSlash("C:\\Users\\User\\Desktop\\Golang"))28}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.