libcw/cwSfScoreParser.cpp

1137 lines
35 KiB
C++
Raw Normal View History

#include "cwCommon.h"
#include "cwLog.h"
#include "cwCommonImpl.h"
#include "cwMem.h"
#include "cwText.h"
#include "cwObject.h"
#include "cwMidi.h"
#include "cwFileSys.h"
#include "cwSfScore.h"
#include "cwCsv.h"
#include "cwNumericConvert.h"
#include "cwTime.h"
#include "cwSfScoreParser.h"
#include "cwSfScore.h"
namespace cw
{
namespace sfscore
{
typedef struct varMap_str
{
unsigned typeId;
unsigned flag;
unsigned endFl;
const char* label;
} varMap_t;
typedef idLabelPair_t opcodeMap_t;
opcodeMap_t _opcodeMapA[] =
{
{ kTimeSigEvtScId, "tsg" },
{ kKeySigEvtScId, "ksg" },
{ kTempoEvtScId, "tmp" },
{ kTrackEvtScId, "trk" },
{ kTextEvtScId, "txt" },
{ kNameEvtScId, "nam" },
{ kEOTrackEvtScId, "eot" },
{ kCopyEvtScId, "cpy" },
{ kBlankEvtScId, "blk" },
{ kBarEvtScId, "bar" },
{ kPgmEvtScId, "pgm" },
{ kCtlEvtScId, "ctl" },
{ kNonEvtScId, "non" },
{ kPedalEvtScId, "ped" },
{ kInvalidId, "<invalid>" }
};
varMap_t _varMapA[] =
{
{ kEvenVarScId, kEvenFl, 0, "e"},
{ kEvenVarScId, kEvenFl | kEvenEndFl, kEvenEndFl, "E"},
{ kDynVarScId, kDynFl, 0, "d"},
{ kDynVarScId, kDynFl | kDynEndFl, kDynEndFl, "D"},
{ kTempoVarScId,kTempoFl, 0, "t"},
{ kTempoVarScId,kTempoFl | kTempoEndFl, kTempoEndFl, "T"},
{ kInvalidId, 0, 0, "<invalid>"}
};
namespace parser
{
typedef struct dynRef_str
{
char* label;
unsigned labelCharCnt;
uint8_t vel;
} dynRef_t;
typedef struct sfscore_parser_str
{
unsigned dynRefN;
dynRef_t* dynRefA;
p_section_t* begSectionL;
p_section_t* endSectionL;
unsigned nextSetId;
p_set_t* begSetL;
p_set_t* endSetL;
unsigned eventAllocN;
unsigned eventN;
p_event_t* eventA;
} sfscore_parser_t;
sfscore_parser_t* _handleToPtr( handle_t h )
{ return handleToPtr<handle_t,sfscore_parser_t>(h); }
unsigned _dyn_label_to_level( sfscore_parser_t* p, const char* dynLabel )
{
const char* end;
unsigned char_cnt;
if( dynLabel == nullptr || textLength(dynLabel)==0 )
return kInvalidDynVel;
end = nextWhiteCharEOS(dynLabel);
assert(end != nullptr );
char_cnt = end - dynLabel;
for(unsigned i=0; i<p->dynRefN; ++i)
if( textCompare(p->dynRefA[i].label,dynLabel,char_cnt) == 0 )
return p->dynRefA[i].vel;
cwLogError(kSyntaxErrorRC,"The dynamic label '%s' is not valid.",cwStringNullGuard(dynLabel));
return kInvalidDynVel;
}
rc_t _destroy( sfscore_parser_t* p )
{
for(p_set_t* s = p->begSetL; s!=nullptr; )
{
p_set_t* s0 = s->link;
mem::release(s->eventA);
mem::release(s);
s = s0;
}
for(p_section_t* s = p->begSectionL; s!=nullptr; )
{
p_section_t* s0 = s->link;
mem::release(s->label);
mem::release(s);
s = s0;
}
for(p_event_t* e = p->eventA; e<p->eventA+p->eventN; ++e)
{
mem::release(e->sciPitch);
for(unsigned i=kMinVarScId; i<kScVarCnt; ++i)
mem::release(e->sectionLabelA[i]);
}
for(dynRef_t* d=p->dynRefA; d<p->dynRefA + p->dynRefN; ++d)
mem::release(d->label);
mem::release(p->dynRefA);
mem::release(p->eventA);
mem::release(p);
return kOkRC;
}
p_section_t* _find_section( sfscore_parser_t* p, const char* section_label)
{
for(p_section_t* s = p->begSectionL; s!=nullptr; s=s->link)
if( textIsEqual(s->label,section_label) )
return s;
return nullptr;
}
p_section_t* _create_section( sfscore_parser_t* p, const char* section_label, unsigned begEvtIdx )
{
p_section_t* s;
if((s = _find_section(p,section_label)) != nullptr )
{
s = nullptr;
cwLogError(kInvalidIdRC,"Duplicate section label (%s) detected.",cwStringNullGuard(section_label));
goto errLabel;
}
else
{
s = mem::allocZ<p_section_t>();
s->label = mem::duplStr(section_label);
s->begEvtIdx = begEvtIdx;
if( p->endSectionL == nullptr )
{
p->endSectionL = s;
assert( p->begSectionL == nullptr );
p->begSectionL = s;
}
else
{
p->endSectionL->link = s;
p->endSectionL = s;
}
}
errLabel:
return s;
}
// Once the var. spec. label is known to have a section id this function extracts the section label
unsigned _parse_set_end_section_label( const char* label, const char*& sectionLabelRef )
{
rc_t rc = kOkRC;
const char* c = nullptr;
sectionLabelRef = nullptr;
// a label with a section will have internal whitespace
if((c = nextWhiteChar(label)) == nullptr )
return rc;
// advance past the white space to the first char of the section id
if( (c=nextNonWhiteChar(c)) == nullptr )
goto errLabel;
// parse the section id
sectionLabelRef = c;
return rc;
errLabel:
return cwLogError(kSyntaxErrorRC,"The section number could not be parsed from '%s'.",label);
}
// Parse the optional set section number following the var spec. label.
rc_t _parse_var_set_section_label(sfscore_parser_t* p, p_event_t* e, const char* label, unsigned varTypeEndFlag, char*& sectionLabelRef )
{
rc_t rc = kOkRC;
const char* section_label = nullptr;
sectionLabelRef = nullptr;
// attempt to get the section id following the var marker
if((rc = _parse_set_end_section_label(label,section_label)) != kOkRC )
goto errLabel;
// if a section id was found then duplicate it
if( section_label != nullptr )
{
sectionLabelRef = mem::duplStr(section_label);
e->flags |= varTypeEndFlag;
}
errLabel:
return rc;
}
// A variable specification indicate how a note is to be measured. It is contained
// in the 'tempo','even', and 'dyn' columns. The specification contains two parts:
// a char string id ('t','e',<dyn mark> (e.g. p,pp,mf,fff,etc)) followed by
// an optional section identifier. The section identifer marks the end
// of a 'set' of var. spec's and also idicates the section which will be modified
// according to the measurements.
rc_t _parse_var_spec( sfscore_parser_t* p, p_event_t* e, const char* mark_label, unsigned varTypeFlag, unsigned varTypeEndFlag, char*& sectionLabelRef )
{
rc_t rc = kOkRC;
unsigned flags = 0;
sectionLabelRef = nullptr;
if( mark_label==nullptr || textLength(mark_label)==0)
return rc;
switch( varTypeFlag )
{
case kDynFl:
if((e->dynVal = _dyn_label_to_level(p,mark_label)) == kInvalidDynVel )
{
cwLogError(kSyntaxErrorRC,"Note dynamic var spec parse failed on label:%s",cwStringNullGuard(mark_label));
goto errLabel;
}
flags |= kDynFl;
break;
case kEvenFl:
case kTempoFl:
flags= var_label_to_type_flag(mark_label);
break;
default:
rc = cwLogError(kSyntaxErrorRC,"The var spec flag '%s' is not valid.",cwStringNullGuard(mark_label));
goto errLabel;
}
if( cwIsFlag(e->flags,varTypeFlag ) )
{
rc = cwLogError(kInvalidIdRC,"The var spec flag was expected to be '%s' but instead was '%s'.",var_type_flag_to_label(varTypeFlag),var_type_flag_to_label(flags));
goto errLabel;
}
// parse the optional section id.
if((rc = _parse_var_set_section_label(p,e,mark_label,varTypeEndFlag,sectionLabelRef)) != kOkRC )
goto errLabel;
e->flags |= flags;
errLabel:
return rc;
}
rc_t _parse_csv_note(sfscore_parser_t* p,
p_event_t* e,
uint8_t d0,
uint8_t d1,
const char* sciPitch,
const char* evenLabel,
const char* tempoLabel,
const char* dynLabel)
{
rc_t rc = kOkRC;
if( textLength(sciPitch)<2 )
{
rc = cwLogError(kSyntaxErrorRC,"Blank or invalid scientific pitch.");
goto errLabel;
}
if((rc = _parse_var_spec(p,e,evenLabel,kEvenFl,kEvenEndFl,e->sectionLabelA[kEvenVarScId] )) != kOkRC )
goto errLabel;
if((rc = _parse_var_spec(p,e,tempoLabel,kTempoFl,kTempoEndFl,e->sectionLabelA[kTempoVarScId] )) != kOkRC )
goto errLabel;
if((rc = _parse_var_spec(p,e,dynLabel,kDynFl,kDynEndFl,e->sectionLabelA[kDynVarScId])) != kOkRC )
goto errLabel;
e->pitch = d0;
e->vel = d1;
e->sciPitch = mem::duplStr(sciPitch);
errLabel:
return rc;
}
rc_t _parse_csv_row( sfscore_parser_t* p,
csv::handle_t& csvH,
unsigned cur_line_idx,
double& curSecRef,
unsigned& curLocIdxRef,
p_section_t*& curSectionRef,
unsigned& curSectionNoteIdxRef,
unsigned& curBarNumbRef,
unsigned& curBarNoteIdxRef )
{
rc_t rc = kOkRC;
const char* opcodeLabel;
const char* arg0;
const char* evenLabel;
const char* tempoLabel;
const char* dynLabel;
uint8_t d0,d1;
const char* sectionLabel;
p_event_t* e = p->eventA + p->eventN;
// verify that there is an available slot in the event array
if( p->eventN >= p->eventAllocN )
{
rc = cwLogError(kBufTooSmallRC,"The event record array is too small.");
goto errLabel;
}
if((rc = getv( csvH,
"opcode",opcodeLabel,
"evt", e->csvEventId,
"micros",e->secs,
"d0",d0,
"d1",d1,
"arg0",arg0,
"bar",e->barNumb,
"even",evenLabel,
"tempo",tempoLabel,
"t_frac",e->t_frac,
"dyn",dynLabel,
"section",sectionLabel )) != kOkRC )
{
rc = cwLogError(rc,"Error parsing score CSV row." );
goto errLabel;
}
// validate the opcode
if((e->typeId = opcode_label_to_id( opcodeLabel )) == kInvalidId )
{
cwLogError(kSyntaxErrorRC,"The opcode type:'%s' is not valid.",cwStringNullGuard(opcodeLabel));
goto errLabel;
}
switch( e->typeId )
{
case kBarEvtScId:
if( curBarNumbRef != kInvalidId && e->barNumb != curBarNumbRef+1 )
{
rc = cwLogError(kInvalidStateRC,"Missig bar number %i. Jumped from bar:%i to bar:%i.", curBarNumbRef+1,curBarNumbRef,e->barNumb);
goto errLabel;
}
curBarNumbRef = e->barNumb;
curBarNoteIdxRef = 0;
break;
case kCtlEvtScId:
break;
case kNonEvtScId:
{
if( e->secs != curSecRef )
{
curSecRef = e->secs;
curLocIdxRef += 1;
}
e->locIdx = curLocIdxRef;
e->index = p->eventN;
e->line = cur_line_idx;
e->csvRowNumb = cur_line_idx+1;
e->barNumb = curBarNumbRef;
e->barNoteIdx = curBarNoteIdxRef++;
if((rc = _parse_csv_note(p,e,d0,d1,arg0,evenLabel,tempoLabel,dynLabel)) != kOkRC )
{
cwLogError(rc,"Note parse failed.");
goto errLabel;
}
// if this event has a section label
if( sectionLabel != nullptr and textLength(sectionLabel)>0 )
{
// locate the section record
if((curSectionRef = _create_section(p,sectionLabel,e->index)) == nullptr )
{
rc = cwLogError(kOpFailRC,"The section label '%s' create failed.",cwStringNullGuard(sectionLabel));
goto errLabel;
}
curSectionNoteIdxRef = 0;
}
e->section = curSectionRef;
e->sectionIdx = curSectionNoteIdxRef;
curSectionNoteIdxRef += 1;
p->eventN += 1;
}
break;
default:
cwLogError(kInvalidArgRC,"The opcode type '%s' is not valid in this context.",cwStringNullGuard(opcodeLabel));
goto errLabel;
break;
}
errLabel:
return rc;
}
rc_t _parse_events( sfscore_parser_t* p, csv::handle_t csvH )
{
rc_t rc;
unsigned cur_line_idx = 0;
double curSec = 0;
unsigned curLocIdx = 0;
p_section_t* curSection = nullptr;
unsigned curSectionNoteIdx = 0;
unsigned curBarNumb = kInvalidId;
unsigned curBarNoteIdx = 0;
// get the line count from the CSV file
if((rc = line_count(csvH,p->eventAllocN)) != kOkRC )
{
rc = cwLogError(rc,"Score CSV line count failed.");
goto errLabel;
}
// allocate the event array
p->eventA = mem::allocZ<p_event_t>(p->eventAllocN);
do
{
cur_line_idx = cur_line_index(csvH);
// advance the CSV line cursor
switch(rc = next_line(csvH))
{
case kOkRC:
{
if((rc = _parse_csv_row(p, csvH, cur_line_idx, curSec, curLocIdx, curSection, curSectionNoteIdx, curBarNumb, curBarNoteIdx )) != kOkRC )
goto errLabel;
}
break;
case kEofRC:
break;
default:
rc = cwLogError(rc,"CSV line iteration error on CSV event parse.");
goto errLabel;
}
}while( rc != kEofRC );
rc = kOkRC;
errLabel:
if( rc != kOkRC )
rc = cwLogError(rc,"CSV parse failed on row number:%i.",cur_line_idx+1);
return rc;
}
rc_t _parse_csv( sfscore_parser_t* p, const char* fname )
{
rc_t rc = kOkRC;
const char* titleA[] = { "id","trk","evt","opcode","dticks","micros","status","meta",
"ch","d0","d1","arg0","arg1","bar","skip","even","grace",
"tempo","t_frac","dyn","section","play_recd","remark" };
unsigned titleN = sizeof(titleA)/sizeof(titleA[0]);
csv::handle_t csvH;
// open the CSV file and validate the title row
if((rc = create( csvH, fname, titleA, titleN )) != kOkRC )
{
rc = cwLogError(rc,"Score CSV parse failed on '%s'.",fname);
goto errLabel;
}
// parse the events
if((rc = _parse_events(p, csvH )) != kOkRC )
goto errLabel;
errLabel:
if(rc != kOkRC )
rc = cwLogError(rc,"CSV parse failed on '%s'.",fname);
destroy(csvH);
return rc;
}
// Allocate a new set record.
p_set_t* _alloc_set( sfscore_parser_t* p, unsigned varTypeId, p_event_t* beg_evt )
{
p_set_t* s = mem::allocZ<p_set_t>();
s->varTypeId = varTypeId;
s->beg_event = beg_evt;
s->id = p->nextSetId++;
if( p->endSetL == nullptr )
{
p->begSetL = s;
p->endSetL = s;
}
else
{
p->endSetL->link = s;
p->endSetL = s;
}
return s;
}
// Fill a set eventA[] by iterating from set->beg_event to 'end_event'
// and storing all events of type set->varTypeid.
rc_t _fill_set( sfscore_parser_t* p, p_set_t* set, p_event_t* end_event )
{
rc_t rc = kOkRC;
unsigned refVarFlag = var_type_id_to_flag(set->varTypeId);
unsigned evtIdx = 0;
set->eventA = mem::allocZ<p_event_t*>(set->eventN);
assert( set->beg_event <= end_event );
for(p_event_t* e = set->beg_event; e<=end_event && evtIdx < set->eventN; ++e)
if( cwIsFlag(e->flags,refVarFlag) )
set->eventA[evtIdx++] = e;
if( evtIdx != set->eventN )
{
rc = cwLogError(kOpFailRC,"%i events were located for set '%i' but %i were filled.",set->eventN,set->id,evtIdx);
goto errLabel;
}
errLabel:
return rc;
}
// Returns true if the event 'e' is the last event in a set of type 'varTypeId'.
bool _is_end_of_set( sfscore_parser_t* p, unsigned varTypeId, p_event_t* e )
{
unsigned varTypeMask = var_type_id_to_mask(varTypeId);
// if this e is marked as end-of-set
if( cwAllFlags(e->flags,varTypeMask) )
{
if( e->index < p->eventN-1 )
{
p_event_t* e1 = e + 1;
// ... and the next event is at the same loc and also marked as end-of-set don't end the set
if( e1->locIdx == e->locIdx && cwAllFlags(e1->flags,varTypeMask) )
{
e->flags = cwClrFlag(e->flags,var_type_id_to_end_flag(varTypeId));
return false;
}
}
return true;
}
return false;
}
// Register an event to the set to which it belongs. If the set does not exist then create it.
// Setup pointers from the set to the event and the set to the event.
rc_t _register_event_with_set( sfscore_parser_t* p, p_event_t* e, unsigned varTypeId, p_set_t*& setRef )
{
rc_t rc = kOkRC;
// if there is no set to register this event in then create a new set
if( setRef == nullptr )
setRef = _alloc_set(p,varTypeId,e);
setRef->eventN += 1;
e->setA[ varTypeId ] = setRef;
// if this event is marked as an end-of-set
if( _is_end_of_set(p,varTypeId,e) )
{
if((rc = _fill_set(p, setRef, e )) != kOkRC )
goto errLabel;
setRef = nullptr;
}
errLabel:
return kOkRC;
}
// Check for the existence of each var type on each event and then register the event with the set.
rc_t _create_sets( sfscore_parser_t* p )
{
rc_t rc = kOkRC;
p_set_t* setA[ kScVarCnt ];
p_event_t* e = p->eventA;
for(unsigned i=kMinVarScId; i<kScVarCnt; ++i)
setA[i] = nullptr;
// for each event
for(; e<p->eventA + p->eventN; ++e)
{
// for each possible var type
for(unsigned refVarTypeId=0; refVarTypeId<kScVarCnt; ++refVarTypeId)
{
// get the flag for this var type
unsigned refVarTypeFlag = var_type_id_to_flag(refVarTypeId);
// is this event of this type of var
if( cwIsFlag(e->flags,refVarTypeFlag) )
{
// insert the event into a set
if((rc = _register_event_with_set(p, e, refVarTypeId, setA[ refVarTypeId ])) != kOkRC )
{
rc = cwLogError(rc,"Event '%s' set registration failed.",var_type_id_to_label(refVarTypeId));
goto errLabel;
}
}
}
}
errLabel:
return rc;
}
// Assign a target section to each set. Since only the last set of a consecutive set of sets
// has a target section id this function iterates backwards throught the events,
// notices the last event in the last set of a group of sets, and then propogates the
// associated target section back to previous sets.
rc_t _assign_set_sections(sfscore_parser_t* p )
{
rc_t rc = kOkRC;
// for each possible var type
for(unsigned refVarTypeId=kMinVarScId; refVarTypeId<kScVarCnt; ++refVarTypeId )
{
p_section_t* section = nullptr;
p_event_t* e = p->eventA + p->eventN - 1;
// iterate backward through the event list
for(; e>=p->eventA; --e)
{
// if this event is the end of a section for this variable type - then previous sets of this type will be assigned to this section
if( e->sectionLabelA[refVarTypeId]!=nullptr )
{
// locate the section
if((section = _find_section( p, e->sectionLabelA[ refVarTypeId ] )) == nullptr )
{
rc = cwLogError(kInvalidIdRC,"The section label '%s' at CSV line '%i' could not be found.", cwStringNullGuard(e->sectionLabelA[ refVarTypeId ]),e->csvRowNumb);
goto errLabel;
}
}
// if this event is assigned to a set of type refVarTypeId
if( e->setA[ refVarTypeId ] != nullptr )
{
// has this set already been assigned to a target
if( e->setA[ refVarTypeId ]->target_section != nullptr && e->setA[ refVarTypeId ]->target_section != section )
{
cwLogWarning("The set '%i' was previously assigned to a different section:'%s' and is now assigned to '%s'.",
e->setA[ refVarTypeId ]->id,
e->setA[ refVarTypeId ]->target_section->label,
section->label);
}
// assign a section to this set
e->setA[ refVarTypeId ]->target_section = section;
}
}
}
errLabel:
return rc;
}
// Validate as many set invariants as possible.
rc_t _validate_sets( sfscore_parser_t* p )
{
rc_t rc = kOkRC;
for(p_set_t* s = p->begSetL; s!=nullptr; s=s->link)
{
// the set must be assigned a target section
if( s->target_section == nullptr )
{
rc = cwLogError(kInvalidStateRC,"Set (id=%i) of type '%s' beginning at (csv row:%i bar:%i bni:%i) has not been assigned a target section.", s->id, var_type_id_to_label(s->varTypeId), s->beg_event->csvRowNumb, s->beg_event->barNumb, s->beg_event->barNoteIdx );
continue;
}
// tempo and even sets must have at least 3 members
if( (s->varTypeId == kEvenVarScId || s->varTypeId == kTempoVarScId) && s->eventN < 3 )
{
cwLogWarning("Set (id=%i) of type '%s' beginning at (csv row:%i bar:%i bni:%i) should have at least 3 members.", s->id, var_type_id_to_label(s->varTypeId), s->beg_event->csvRowNumb, s->beg_event->barNumb, s->beg_event->barNoteIdx );
continue;
}
p_event_t* e0 = nullptr;
// for each set member
for(unsigned i=0; i<s->eventN; ++i)
{
p_event_t* e1 = s->eventA[i];
// the set->eventA[] must be filled with valid pointers
if( e1 == nullptr )
{
rc = cwLogError(kInvalidStateRC,"Set (id=%i) of type '%s' beginning at (csv row:%i bar:%i bni:%i) contains a NULL event.", s->id, var_type_id_to_label(s->varTypeId), s->beg_event->csvRowNumb, s->beg_event->barNumb, s->beg_event->barNoteIdx );
goto errLabel;
}
// the events contained in this set must also point to this set
if( e1->setA[ s->varTypeId ] != s )
rc = cwLogError(kInvalidStateRC,"Set (id=%i) of type '%s' contains an event (csv row:%i bar:%i bni:%i) whose set pointer is not pointing to this set.", s->id, var_type_id_to_label(s->varTypeId), e1->csvRowNumb, e1->barNumb, e1->barNoteIdx );
// the events must be ordered in increasing time
if( e0 != nullptr && e0->secs > e1->secs )
rc = cwLogError(kInvalidStateRC,"Set (id=%i) of type '%s' contains an event (csv row:%i bar:%i bni:%i) which is out of time order with the previous set event.", s->id,var_type_id_to_label(s->varTypeId), e1->csvRowNumb, e1->barNumb, e1->barNoteIdx );
// the locations must be ordered in increasing time
if( e0 != nullptr && e0->locIdx > e1->locIdx )
rc = cwLogError(kInvalidStateRC,"Set (id=%i) of type '%s' contains an event (csv row:%i bar:%i bni:%i) which is out of loc. order with the previous set event.", s->id,var_type_id_to_label(s->varTypeId), e1->csvRowNumb, e1->barNumb, e1->barNoteIdx );
e0 = e1;
}
}
errLabel:
return rc;
}
// Set section targets must occur on events prior to the first event in the target section
rc_t _validate_section_assignments( sfscore_parser_t* p )
{
rc_t rc = kOkRC;
// for each event
for(p_event_t* e=p->eventA; e<p->eventA+p->eventN; ++e)
{
// verify that this event has been assigned to a section
if( e->section == nullptr )
{
rc = cwLogError(kInvalidStateRC,"The event at csv row:%i bar:%i bni:%i was not assigned to a section.",
e->csvRowNumb,e->barNumb,e->barNoteIdx);
continue;
}
// for each possible var type that this event may belong to
for(unsigned refVarTypeId=kMinVarScId; refVarTypeId<kScVarCnt; ++refVarTypeId)
if( e->setA[ refVarTypeId ] != nullptr )
{
// verify that the target section for this set begins after this event
if( textCompare(e->setA[ refVarTypeId ]->target_section->label,e->section->label) <= 0 )
{
rc = cwLogError(kInvalidStateRC,"The target section for '%s' of the event at csv row:%i bar:%i bni:%i is after the event.",
var_type_id_to_label(refVarTypeId),e->csvRowNumb,e->barNumb,e->barNoteIdx);
continue;
}
}
}
return rc;
}
}
}
}
unsigned cw::sfscore::opcode_label_to_id( const char* label )
{
unsigned id;
if((id = labelToId( _opcodeMapA, label, kInvalidId )) == kInvalidId )
cwLogError(kInvalidArgRC,"'%s' is not a valid event opcode type label.",cwStringNullGuard(label));
return id;
}
const char* cw::sfscore::opcode_id_to_label( unsigned opcode_id )
{
const char* label;
if((label = idToLabelNull( _opcodeMapA, opcode_id, kInvalidEvtScId)) == nullptr )
cwLogError(kInvalidArgRC,"The event opcode type id '%i' is not valid.",opcode_id);
return label;
}
unsigned cw::sfscore::var_label_to_type_id( const char* label )
{
if( label!=nullptr && textLength(label)>0 )
{
char varLabel[] = { label[0],0 };
for(unsigned i=0; _varMapA[i].typeId != kInvalidId; ++i)
if( textCompare(varLabel,_varMapA[i].label) == 0 )
return _varMapA[i].typeId;
}
cwLogError(kInvalidArgRC,"The variable label '%s' is not valid.",cwStringNullGuard(label));
return kInvalidId;
}
unsigned cw::sfscore::var_label_to_type_flag( const char* varLabel )
{
if(varLabel==nullptr || textLength(varLabel) == 0)
return 0;
for(unsigned i=0; _varMapA[i].typeId != kInvalidId; ++i)
if( textCompare(_varMapA[i].label,varLabel,textLength(_varMapA[i].label))==0 )
return _varMapA[i].flag;
cwLogError(kInvalidArgRC,"The variable type label '%s' is not valid.",cwStringNullGuard(varLabel));
return 0;
}
const char* cw::sfscore::var_type_id_to_label( unsigned varTypeId )
{
for(unsigned i=0; _varMapA[i].typeId != kInvalidId; ++i)
if( _varMapA[i].typeId == varTypeId )
return _varMapA[i].label;
cwLogError(kInvalidArgRC,"The variable type id '%i' is not valid.",varTypeId);
return nullptr;
}
const char* cw::sfscore::var_type_flag_to_label( unsigned varTypeFlag )
{
for(unsigned i=0; _varMapA[i].typeId != kInvalidId; ++i)
if( _varMapA[i].flag == (varTypeFlag & kFlagMask) )
return _varMapA[i].label;
return nullptr;
}
char cw::sfscore::var_type_flag_to_char( unsigned varTypeFlag )
{
const char* s;
if((s = var_type_flag_to_label(varTypeFlag)) != nullptr )
return *s;
return ' ';
}
unsigned cw::sfscore::var_type_id_to_flag( unsigned varTypeId )
{
for(unsigned i=0; _varMapA[i].typeId != kInvalidId; ++i)
if( _varMapA[i].typeId == varTypeId && _varMapA[i].endFl == false )
return _varMapA[i].flag;
return 0;
}
unsigned cw::sfscore::var_type_id_to_mask( unsigned varTypeId )
{
for(unsigned i=0; _varMapA[i].typeId != kInvalidId; ++i)
if( _varMapA[i].typeId == varTypeId && _varMapA[i].endFl )
return _varMapA[i].flag;
return 0;
}
unsigned cw::sfscore::var_type_id_to_end_flag( unsigned varTypeId )
{
for(unsigned i=0; _varMapA[i].typeId != kInvalidId; ++i)
if( _varMapA[i].typeId == varTypeId && _varMapA[i].endFl )
return _varMapA[i].endFl;
return 0;
}
unsigned cw::sfscore::var_type_flag_to_id( unsigned varTypeFlag )
{
for(unsigned i=0; _varMapA[i].typeId != kInvalidId; ++i)
if( _varMapA[i].flag == varTypeFlag )
return _varMapA[i].typeId;
cwLogError(kInvalidArgRC,"The variable flag id '0x%x' is not valid.",varTypeFlag);
return kInvalidId;
}
cw::rc_t cw::sfscore::parser::create( handle_t& hRef, const char* fname, const dyn_ref_t* dynRefA, unsigned dynRefN )
{
rc_t rc;
if((rc = destroy(hRef)) != kOkRC )
return rc;
sfscore_parser_t* p = mem::allocZ<sfscore_parser_t>();
p->dynRefN = dynRefN;
p->dynRefA = mem::allocZ<dynRef_t>(p->dynRefN);
for(unsigned i=0; i<p->dynRefN; ++i)
{
if( dynRefA[i].vel == kInvalidDynVel )
{
cwLogError(kInvalidArgRC,"The value '%i' is reserved to mark invalid values and cannot be used in the dynamic reference array.",kInvalidDynVel);
goto errLabel;
}
else
{
p->dynRefA[i].label = mem::duplStr(dynRefA[i].label);
p->dynRefA[i].labelCharCnt = textLength(dynRefA[i].label);
p->dynRefA[i].vel = dynRefA[i].vel;
}
}
if((rc = _parse_csv( p, fname )) != kOkRC )
{
rc = cwLogError(rc,"sfscore CSV parse failed.");
goto errLabel;
}
if((rc = _create_sets(p)) != kOkRC )
{
rc = cwLogError(rc,"sfscore var. set creation failed.");
goto errLabel;
}
if((rc = _assign_set_sections(p)) != kOkRC )
{
rc = cwLogError(rc,"sfscore set target section assignmet failed.");
goto errLabel;
}
if((rc = _validate_sets( p )) != kOkRC )
{
rc = cwLogError(rc,"sfscore set validation failed.");
goto errLabel;
}
if((rc = _validate_section_assignments( p )) != kOkRC )
goto errLabel;
hRef.set(p);
errLabel:
if( rc != kOkRC )
{
rc = cwLogError(rc,"sfscore create failed on '%s'.",cwStringNullGuard(fname));
_destroy(p);
}
return rc;
}
cw::rc_t cw::sfscore::parser::destroy( handle_t& hRef )
{
rc_t rc = kOkRC;
sfscore_parser_t* p = nullptr;;
if( !hRef.isValid() )
return rc;
p = _handleToPtr(hRef);
if((rc = _destroy(p)) != kOkRC )
return rc;
hRef.clear();
return rc;
}
unsigned cw::sfscore::parser::event_count( handle_t h )
{
sfscore_parser_t* p = _handleToPtr(h);
return p->eventN;
}
const cw::sfscore::parser::p_event_t* cw::sfscore::parser::event_array( handle_t h )
{
sfscore_parser_t* p = _handleToPtr(h);
return p->eventA;
}
unsigned cw::sfscore::parser::section_count( handle_t h )
{
sfscore_parser_t* p = _handleToPtr(h);
unsigned n=0;
for(p_section_t* s=p->begSectionL; s!=nullptr; s=s->link)
++n;
return n;
}
const cw::sfscore::parser::p_section_t* cw::sfscore::parser::section_list( handle_t h )
{
sfscore_parser_t* p = _handleToPtr(h);
return p->begSectionL;
}
unsigned cw::sfscore::parser::set_count( handle_t h )
{
sfscore_parser_t* p = _handleToPtr(h);
unsigned n=0;
for(p_set_t* s=p->begSetL; s!=nullptr; s=s->link)
++n;
return n;
}
const cw::sfscore::parser::p_set_t* cw::sfscore::parser::set_list( handle_t h )
{
sfscore_parser_t* p = _handleToPtr(h);
return p->begSetL;
}
void cw::sfscore::parser::report( handle_t h )
{
sfscore_parser_t* p = _handleToPtr(h);
unsigned bar0 = 0;
const char* sec0 = nullptr;
const char* blank_str = " ";
const char* sec_str = "S:";
const char* bar_str = "B:";
printf("e idx loc secs op sectn sdx bar bdx scip vel frac\n");
printf("----- ----- ------- --- ------ --- ----- --- ---- --- -----\n");
for(p_event_t* e = p->eventA; e<p->eventA+p->eventN; ++e)
{
const char* d_bar_str = bar0 != e->barNumb ? bar_str : blank_str;
const char* d_sec_str = e->section != nullptr && textIsEqual(sec0,e->section->label) ? blank_str : sec_str;
bar0 = e->barNumb;
if( e->section != nullptr )
sec0 = e->section->label;
printf("%5i %5i %7.3f %3s %2s%4s %3i %2s%3i %3i %4s %3i %5.3f ",
e->index,
e->locIdx,
e->secs,
opcode_id_to_label(e->typeId),
d_sec_str,
e->section==nullptr ? " " : cwStringNullGuard(e->section->label),
e->sectionIdx,
d_bar_str,
e->barNumb,
e->barNoteIdx,
e->sciPitch,
e->vel,
e->t_frac );
for(unsigned refVarTypeId=kMinVarScId; refVarTypeId<kScVarCnt; ++refVarTypeId)
{
if( e->setA[refVarTypeId] == nullptr )
printf(" ");
else
{
unsigned varRefFlags = var_type_id_to_mask(refVarTypeId);
const char* sect_label = e->setA[refVarTypeId]->target_section==nullptr ? "****" : e->setA[refVarTypeId]->target_section->label;
printf("%c-%03i-%s ",var_type_flag_to_char(e->flags & varRefFlags), e->setA[refVarTypeId]->id, sect_label);
}
}
printf("\n");
}
}
cw::rc_t cw::sfscore::parser::test( const char* fname, const dyn_ref_t* dynRefA, unsigned dynRefN )
{
handle_t h;
rc_t rc;
if((rc = create(h,fname,dynRefA,dynRefN)) != kOkRC )
goto errLabel;
errLabel:
if( rc != kOkRC )
rc = cwLogError(rc,"Parser test failed.");
rc_t rc1 = destroy(h);
return rcSelect(rc,rc1);
}