// Copyright 2016 Viacheslav Chimishuk <vchimishuk@yandex.ru>//// This file is part of Chub.//// Chub is free software: you can redistribute it and/or modify// it under the terms of the GNU General Public License as published by// the Free Software Foundation, either version 3 of the License, or// (at your option) any later version.//// Chub is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the// GNU General Public License for more details.//// You should have received a copy of the GNU General Public License// along with Chub. If not, see <http://www.gnu.org/licenses/>. // Package cue implement CUE-SHEET files parser.// For CUE documentation see: http://digitalx.org/cue-sheet/syntax///// TODO: Create parser specific Error (with line number and others).package cue import (	"bufio"	"errors"	"fmt"	"io"	"log"	"os"	"regexp"	"strconv"	"strings") // commandParser is the function for parsing one command.type commandParser func(params []string, sheet *Sheet) error // commandParserDesctiptor describes command parser.type commandParserDescriptor struct {	// -1 -- zero or more parameters.	paramsCount int	parser      commandParser} // parsersMap used for commands and parser functions correspondence.var parsersMap = map[string]commandParserDescriptor{	"CATALOG":    {1, parseCatalog},	"CDTEXTFILE": {1, parseCdTextFile},	"FILE":       {2, parseFile},	"FLAGS":      {-1, parseFlags},	"INDEX":      {2, parseIndex},	"ISRC":       {1, parseIsrc},	"PERFORMER":  {1, parsePerformer},	"POSTGAP":    {1, parsePostgap},	"PREGAP":     {1, parsePregap},	"REM":        {-1, parseRem},	"SONGWRITER": {1, parseSongWriter},	"TITLE":      {1, parseTitle},	"TRACK":      {2, parseTrack},} const (	// FlagTruncateStrings enables 80-char string truncation to conform the specification.	FlagTruncateStrings = 1 << iota) // ParseFile parses cue-sheet tile.func ParseFile(filename string, flags int) (sheet *Sheet, err error) {	file, err := os.Open(filename)	if err != nil {		return nil, err	}	defer file.Close() 	return Parse(file, flags)} // Parse parses cue-sheet data from reader and returns filled Sheet struct.func Parse(reader io.Reader, flags int) (sheet *Sheet, err error) {	sheet = &Sheet{flags: flags} 	rd := bufio.NewReader(reader)	lineNumber := 1 	for buf, _, err := rd.ReadLine(); err != io.EOF; buf, _, err = rd.ReadLine() {		if err != nil {			return nil, err		} 		line := strings.TrimSpace(string(buf)) 		// Skip empty lines.		if len(line) == 0 {			continue		} 		cmd, params, err := parseCommand(line)		if err != nil {			return nil, fmt.Errorf("Line %d. %s", lineNumber, err)		} 		parserDescriptor, ok := parsersMap[cmd]		if !ok {			return nil, fmt.Errorf("Line %d. Unknown command '%s'.", lineNumber, cmd)		} 		paramsExpected := parserDescriptor.paramsCount		paramsRecieved := len(params)		if paramsExpected != -1 && paramsExpected != paramsRecieved {			return nil, fmt.Errorf("Line %d. Command %s expected %d parameters but %d received.",				lineNumber, cmd, paramsExpected, paramsRecieved)		} 		err = parserDescriptor.parser(params, sheet)		if err != nil {			return nil, fmt.Errorf("Line %d. %s", lineNumber, err)		} 		lineNumber++	} 	return sheet, nil} // parseCatalog parsers CATALOG command.func parseCatalog(params []string, sheet *Sheet) error {	num := params[0] 	// TODO: Optimize regexp.	matched, _ := regexp.MatchString("^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]$", num)	if !matched {		return fmt.Errorf("%s is not valid catalog number.", params)	} 	sheet.Catalog = num 	return nil} // parseCdTextFile parsers CDTEXTFILE command.func parseCdTextFile(params []string, sheet *Sheet) error {	sheet.CdTextFile = params[0] 	return nil} func parseFileType(t string) (FileType, error) {	t = strings.ToTitle(t)	switch t {	case "BINARY":		return FileTypeBinary, nil	case "MOTOROLA":		return FileTypeMotorola, nil	case "AIFF":		return FileTypeAiff, nil	case "WAVE":		return FileTypeWave, nil	case "MP3":		return FileTypeMp3, nil	case "FLAC":		return FileTypeFlac, nil	default:		return 0, fmt.Errorf("Unsupported file type %s.", t)	}} // parseFile parsers FILE command.// params[0] -- fileName// params[1] -- fileTypefunc parseFile(params []string, sheet *Sheet) error {	fileType, err := parseFileType(params[1])	if err != nil {		return err	} 	sheet.Files = append(sheet.Files, &File{		Name: params[0],		Type: fileType,	}) 	return nil} // parseFlags parsers FLAGS command.func parseFlags(params []string, sheet *Sheet) error {	flagParser := func(flag string) (trackFlag TrackFlag, err error) {		var flags = map[string]TrackFlag{			"DCP":  TrackFlagDcp,			"4CH":  TrackFlag4ch,			"PRE":  TrackFlagPre,			"SCMS": TrackFlagScms,		} 		trackFlag, ok := flags[flag]		if !ok {			err = fmt.Errorf("Unsupported track flag %s.", flag)		} 		return	} 	track := getCurrentTrack(sheet)	if track == nil {		return errors.New("TRACK command should appears before FLAGS command.")	} 	for _, flagStr := range params {		flag, err := flagParser(flagStr)		if err != nil {			return err		}		track.Flags = append(track.Flags, flag)	} 	return nil} // parseIndex parsers INDEX command.func parseIndex(params []string, sheet *Sheet) error {	min, sec, frames, err := parseTime(params[1])	if err != nil {		return err	} 	number, err := strconv.Atoi(params[0])	if err != nil {		return err	} 	// All index numbers must be between 0 and 99 inclusive.	if number < 0 || number > 99 {		return errors.New("Invalid index number value.")	} 	track := getCurrentTrack(sheet)	if track == nil {		return fmt.Errorf("TRACK command expected.")	} 	// The first index of a file must start at 00:00:00.	// Ignore this error, some CUE sheets don't have it	if getFileLastIndex(getCurrentFile(sheet)) == nil {		if min+sec+frames != 0 {			log.Printf("INDEX 00 00:00:00 missing")		}	} 	// This is the first track index?	if len(track.Indexes) == 0 {		// The first index must be 0 or 1.		if number >= 2 {			return errors.New("0 or 1 index number expected.")		}	} else {		// All other indexes being sequential to the first one.		numberExpected := track.Indexes[len(track.Indexes)-1].Number + 1		if numberExpected != number {			return fmt.Errorf("%d index number expected.", numberExpected)		}	} 	track.Indexes = append(track.Indexes, &Index{		Number: number,		Time: &Time{			Min:    min,			Sec:    sec,			Frames: frames,		},	}) 	return nil} // parseIsrc parsers ISRC command.func parseIsrc(params []string, sheet *Sheet) error {	isrc := params[0] 	track := getCurrentTrack(sheet)	if track == nil {		return errors.New("TRACK command expected.")	} 	if len(track.Indexes) != 0 {		return errors.New("ISRC command expected.")	} 	// TODO: Shame on you for this regexp.	re := "^[0-9a-zA-z][0-9a-zA-z][0-9a-zA-z][0-9a-zA-z][0-9a-zA-z]" +		"[0-9][0-9][0-9][0-9][0-9][0-9][0-9]$"	matched, _ := regexp.MatchString(re, isrc)	if !matched {		return fmt.Errorf("%s is not valid ISRC number.", isrc)	} 	track.Isrc = isrc 	return nil} // parsePerformer parsers PERFORMER command.func parsePerformer(params []string, sheet *Sheet) error {	performer := sheet.stringTruncateMaybe(params[0], 80)	track := getCurrentTrack(sheet) 	if track == nil {		// Performer command for the CD disk.		sheet.Performer = performer	} else {		// Performer command for track.		track.Performer = performer	} 	return nil} // parsePostgap parsers POSTGAP command.func parsePostgap(params []string, sheet *Sheet) error {	track := getCurrentTrack(sheet)	if track == nil {		return errors.New("TRACK command expected.")	} 	min, sec, frames, err := parseTime(params[0])	if err != nil {		return err	} 	track.Postgap = &Time{Min: min, Sec: sec, Frames: frames} 	return nil} // parsePregap parsers PREGAP command.func parsePregap(params []string, sheet *Sheet) error {	track := getCurrentTrack(sheet)	if track == nil {		return errors.New("TRACK command expected.")	} 	if len(track.Indexes) != 0 {		return errors.New("Unexpected PREGAP command.")	} 	min, sec, frames, err := parseTime(params[0])	if err != nil {		return err	} 	track.Pregap = &Time{Min: min, Sec: sec, Frames: frames} 	return nil} // parseRem parsers REM command.func parseRem(params []string, sheet *Sheet) error {	comment := strings.Join(params, " ")	track := getCurrentTrack(sheet) 	if track == nil {		// Comment for the CD disk.		sheet.Comments = append(sheet.Comments, comment)	} else {		// Comment for the track.		track.Comments = append(track.Comments, comment)	} 	return nil} // parseSongWriter parsers SONGWRITER command.func parseSongWriter(params []string, sheet *Sheet) error {	songwriter := sheet.stringTruncateMaybe(params[0], 80)	track := getCurrentTrack(sheet) 	if track == nil {		sheet.Songwriter = songwriter	} else {		track.Songwriter = songwriter	} 	return nil} // parseTitle parsers TITLE command.func parseTitle(params []string, sheet *Sheet) error {	title := sheet.stringTruncateMaybe(params[0], 80)	track := getCurrentTrack(sheet) 	if track == nil {		// Title for the CD disk.		sheet.Title = title	} else {		// Title command for track.		track.Title = title	} 	return nil} // parseTrack parses TRACK command.func parseTrack(params []string, sheet *Sheet) error {	// TRACK command should be after FILE command.	if len(sheet.Files) == 0 {		return fmt.Errorf("Unexpected TRACK command.")	} 	numberStr := params[0]	dataTypeStr := params[1] 	// Type parser function.	parseDataType := func(t string) (dataType TrackDataType, err error) {		var types = map[string]TrackDataType{			"AUDIO":      DataTypeAudio,			"CDG":        DataTypeCdg,			"MODE1/2048": DataTypeMode1_2048,			"MODE1/2352": DataTypeMode1_2352,			"MODE2/2336": DataTypeMode2_2336,			"MODE2/2352": DataTypeMode2_2352,			"MODEx/2xxx": DataTypeModeX_2XXX,			"CDI/2336":   DataTypeCdi_2336,			"CDI/2352":   DataTypeCdi_2352,		} 		dataType, ok := types[t]		if !ok {			err = fmt.Errorf("Unsupported track datatype %s.", t)		} 		return	} 	number, err := strconv.Atoi(numberStr)	if err != nil {		return err	}	if number < 1 {		return fmt.Errorf("Bad track number value.")	} 	dataType, err := parseDataType(dataTypeStr)	if err != nil {		return err	} 	track := &Track{		Number:   number,		DataType: dataType,	} 	file := sheet.Files[len(sheet.Files)-1] 	// But all track numbers after the first must be sequential.	if len(file.Tracks) > 0 {		if file.Tracks[len(file.Tracks)-1].Number != number-1 {			return fmt.Errorf("Expected track number %d, but %d received.",				number-1, number)		}	} 	file.Tracks = append(file.Tracks, track) 	return nil} // getCurrentFile returns file object started with the last FILE command.// Returns nil if there is no any File objects.func getCurrentFile(sheet *Sheet) *File {	if len(sheet.Files) == 0 {		return nil	} 	return sheet.Files[len(sheet.Files)-1]} // getCurrentTrack returns current track object, which was started with last TRACK command.// Returns nil if there is no any Track object avaliable.func getCurrentTrack(sheet *Sheet) *Track {	file := getCurrentFile(sheet)	if file == nil {		return nil	} 	if len(file.Tracks) == 0 {		return nil	} 	return file.Tracks[len(file.Tracks)-1]} // getFileLastIndex returns last index for the given file.// Returns nil if file has no any indexes.func getFileLastIndex(file *File) *Index {	for i := len(file.Tracks) - 1; i >= 0; i-- {		track := file.Tracks[i] 		for j := len(track.Indexes) - 1; j >= 0; j-- {			return track.Indexes[j]		}	}

Lines 1–500 of 503. Load more