void Fstring_left_trim(CL_FORM *base) { Fstring(ARG(1)); LOAD_FIXNUM(ARG(2), 0, ARG(2)); M1_1:; COPY(ARG(2), ARG(3)); COPY(ARG(1), ARG(4)); Flength(ARG(4)); Fnumeql(ARG(3), 2); if(CL_TRUEP(ARG(3))) { LOAD_SMSTR((CL_FORM *)&KClisp[70], ARG(0)); /* */ goto RETURN1; } COPY(ARG(1), ARG(3)); Fstringp(ARG(3)); if(CL_TRUEP(ARG(3))) { } else { COPY(SYMVAL(Slisp, 58), ARG(3)); /* WRONG_TYPE */ COPY(ARG(1), ARG(4)); LOAD_SYMBOL(SYMBOL(Slisp, 44), ARG(5)); /* STRING */ Ferror(ARG(3), 3); } COPY(ARG(1), ARG(3)); COPY(ARG(2), ARG(4)); Frow_major_aref(ARG(3)); COPY(ARG(0), ARG(4)); LOAD_SYMBOL(SYMBOL(Slisp, 282), ARG(5)); /* TEST */ LOAD_GLOBFUN(&CFcharE, ARG(6)); Ffind(ARG(3), 4); if(CL_TRUEP(ARG(3))) { } else { goto RETURN2; } F1plus(ARG(2)); goto M1_1; RETURN2:; COPY(ARG(2), ARG(3)); Fzerop(ARG(3)); if(CL_TRUEP(ARG(3))) { COPY(ARG(1), ARG(0)); } else { COPY(ARG(1), ARG(0)); COPY(ARG(2), ARG(1)); LOAD_NIL(ARG(2)); subseq1(ARG(0)); } RETURN1:; }
void string_to_simple_string(CL_FORM *base) { if(CL_SMSTRP(ARG(0))) { } else { COPY(ARG(0), ARG(1)); Fstringp(ARG(1)); if(CL_TRUEP(ARG(1))) { COPY(ARG(0), ARG(1)); complex_vector_displaced(ARG(1)); Fminusp(ARG(1)); if(CL_TRUEP(ARG(1))) { COPY(ARG(0), ARG(1)); complex_vector_fillptr(ARG(1)); Fminusp(ARG(1)); } else { goto ELSE1; } if(CL_TRUEP(ARG(1))) { complex_vector_data(ARG(0)); } else { ELSE1:; LOAD_FIXNUM(ARG(1), 0, ARG(1)); LOAD_NIL(ARG(2)); subseq1(ARG(0)); } } else { COPY(SYMVAL(Slisp, 58), ARG(1)); /* WRONG_TYPE */ COPY(ARG(0), ARG(2)); LOAD_SYMBOL(SYMBOL(Slisp, 44), ARG(3)); /* STRING */ Ferror(ARG(1), 3); } } }
void M2MFstAligner::Sequences2FSTNoInit( VectorFst<LogArc>* fst, vector<string>* seq1, vector<string>* seq2 ){ /* Build an FST that represents all possible alignments between seq1 and seq2, given the parameter values input by the user. Here we encode the input and output labels, in fact creating a WFSA. This simplifies the training process, but means that we can only easily compute a joint maximization. In practice joint maximization seems to give the best results anyway, so it probably doesn't matter. */ int istate=0; int ostate=0; for( unsigned int i=0; i<=seq1->size(); i++ ){ for( unsigned int j=0; j<=seq2->size(); j++ ){ fst->AddState(); istate = i*(seq2->size()+1)+j; //Epsilon arcs for seq1 if( seq1_del==true ) for( unsigned int l=1; l<=seq2_max; l++ ){ if( j+l<=seq2->size() ){ vector<string> subseq2( seq2->begin()+j, seq2->begin()+j+l ); int is = isyms->Find(skip+s1s2_sep+vec2str(subseq2, seq2_sep)); ostate = i*(seq2->size()+1) + (j+l); LogArc arc( is, is, alignment_model[is], ostate ); _compute_penalties( arc.ilabel, 1, l, true, false ); fst->AddArc( istate, arc ); } } //Epsilon arcs for seq2 if( seq2_del==true ) for( unsigned int k=1; k<=seq1_max; k++ ){ if( i+k<=seq1->size() ){ vector<string> subseq1( seq1->begin()+i, seq1->begin()+i+k ); int is = isyms->Find(vec2str(subseq1, seq1_sep)+s1s2_sep+skip); ostate = (i+k)*(seq2->size()+1) + j; LogArc arc( is, is, alignment_model[is], ostate ); _compute_penalties( arc.ilabel, k, 1, false, true ); fst->AddArc( istate, arc ); } } //All the other arcs for( unsigned int k=1; k<=seq1_max; k++ ){ for( unsigned int l=1; l<=seq2_max; l++ ){ if( i+k<=seq1->size() && j+l<=seq2->size() ){ vector<string> subseq1( seq1->begin()+i, seq1->begin()+i+k ); string s1 = vec2str(subseq1, seq1_sep); vector<string> subseq2( seq2->begin()+j, seq2->begin()+j+l ); string s2 = vec2str(subseq2, seq2_sep); if( restrict==true && l>1 && k>1) continue; int is = isyms->Find(s1+s1s2_sep+s2); ostate = (i+k)*(seq2->size()+1) + (j+l); LogArc arc( is, is, alignment_model[is], ostate ); _compute_penalties( arc.ilabel, k, l, false, false ); fst->AddArc( istate, arc ); } } } } } fst->SetStart(0); fst->SetFinal( ((seq1->size()+1)*(seq2->size()+1))-1, LogWeight::One() ); //Unless seq1_del==true && seq2_del==true we will have unconnected states // thus we need to run connect to clean out these states if( seq1_del==false || seq2_del==false ) Connect(fst); return; }
void M2MFstAligner::Sequences2FST( VectorFst<LogArc>* fst, vector<string>* seq1, vector<string>* seq2 ){ /* Build an FST that represents all possible alignments between seq1 and seq2, given the parameter values input by the user. Here we encode the input and output labels, in fact creating a WFSA. This simplifies the training process, but means that we can only easily compute a joint maximization. In practice joint maximization seems to give the best results anyway, so it probably doesn't matter. Note: this also performs the initizization routine. It performs a UNIFORM initialization meaning that every non-null alignment sequence is eventually initialized to 1/Num(unique_alignments). It might be more appropriate to consider subsequence length here, but for now we stick to the m2m-aligner approach. TODO: Add an FST version and support for conditional maximization. May be useful for languages like Japanese where there is a distinct imbalance in the seq1->seq2 length correspondences. */ int istate=0; int ostate=0; for( unsigned int i=0; i<=seq1->size(); i++ ){ for( unsigned int j=0; j<=seq2->size(); j++ ){ fst->AddState(); istate = i*(seq2->size()+1)+j; //Epsilon arcs for seq1 if( seq1_del==true ) for( unsigned int l=1; l<=seq2_max; l++ ){ if( j+l<=seq2->size() ){ vector<string> subseq2( seq2->begin()+j, seq2->begin()+j+l ); int is = isyms->AddSymbol(skip+s1s2_sep+vec2str(subseq2, seq2_sep)); ostate = i*(seq2->size()+1) + (j+l); LogArc arc( is, is, 99, ostate ); fst->AddArc( istate, arc ); /* if( prev_alignment_model.find(arc.ilabel)==prev_alignment_model.end() ){ prev_alignment_model.insert( pair<LogArc::Label,LogWeight>(arc.ilabel,arc.weight) ); _compute_penalties( arc.ilabel, 1, l, true, false ); }else{ prev_alignment_model[arc.ilabel] = Plus(prev_alignment_model[arc.ilabel],arc.weight); } total = Plus( total, arc.weight ); */ } } //Epsilon arcs for seq2 if( seq2_del==true ) for( unsigned int k=1; k<=seq1_max; k++ ){ if( i+k<=seq1->size() ){ vector<string> subseq1( seq1->begin()+i, seq1->begin()+i+k ); int is = isyms->AddSymbol(vec2str(subseq1, seq1_sep)+s1s2_sep+skip); ostate = (i+k)*(seq2->size()+1) + j; LogArc arc( is, is, 99, ostate ); fst->AddArc( istate, arc ); /* if( prev_alignment_model.find(arc.ilabel)==prev_alignment_model.end() ){ prev_alignment_model.insert( pair<LogArc::Label,LogWeight>(arc.ilabel,arc.weight) ); _compute_penalties( arc.ilabel, k, 1, false, true ); }else{ prev_alignment_model[arc.ilabel] = Plus(prev_alignment_model[arc.ilabel],arc.weight); } total = Plus(total, arc.weight); */ } } //All the other arcs for( unsigned int k=1; k<=seq1_max; k++ ){ for( unsigned int l=1; l<=seq2_max; l++ ){ if( i+k<=seq1->size() && j+l<=seq2->size() ){ vector<string> subseq1( seq1->begin()+i, seq1->begin()+i+k ); string s1 = vec2str(subseq1, seq1_sep); vector<string> subseq2( seq2->begin()+j, seq2->begin()+j+l ); string s2 = vec2str(subseq2, seq2_sep); //This says only 1-M and N-1 allowed, no M-N links! if( restrict==true && l>1 && k>1) continue; int is = isyms->AddSymbol(s1+s1s2_sep+s2); ostate = (i+k)*(seq2->size()+1) + (j+l); LogArc arc( is, is, LogWeight::One().Value()*(k+l), ostate ); fst->AddArc( istate, arc ); //During the initialization phase, just count non-eps transitions //We currently initialize to uniform probability so there is also // no need to tally anything here. /* if( prev_alignment_model.find(arc.ilabel)==prev_alignment_model.end() ){ prev_alignment_model.insert( pair<LogArc::Label,LogWeight>(arc.ilabel, arc.weight) ); _compute_penalties( arc.ilabel, k, l, false, false ); }else{ prev_alignment_model[arc.ilabel] = Plus(prev_alignment_model[arc.ilabel],arc.weight); } total = Plus( total, arc.weight ); */ } } } } } fst->SetStart(0); fst->SetFinal( ((seq1->size()+1)*(seq2->size()+1))-1, LogWeight::One() ); //Unless seq1_del==true && seq2_del==true we will have unconnected states // thus we need to run connect to clean out these states if( seq1_del==false || seq2_del==false ) Connect(fst); //Only add arcs that are in the FINAL fst to the model for( StateIterator<VectorFst<LogArc> > siter(*fst); !siter.Done(); siter.Next() ){ LogArc::StateId q = siter.Value(); for( ArcIterator<VectorFst<LogArc> > aiter(*fst, q); !aiter.Done(); aiter.Next() ){ const LogArc& arc = aiter.Value(); if( prev_alignment_model.find(arc.ilabel)==prev_alignment_model.end() ){ prev_alignment_model.insert( pair<LogArc::Label,LogWeight>(arc.ilabel, arc.weight) ); string sym = isyms->Find(arc.ilabel); size_t del = sym.find("}"); size_t ski = sym.find("_"); size_t chu = sym.find("|"); int k=1; int l=1; bool xd = false; bool yd = false; if( chu!=string::npos ){ if( chu<del ) k += 1; else l += 1; } if( ski!=string::npos ){ if( ski<del ) xd = true; else yd = true; } _compute_penalties( arc.ilabel, k, l, false, false ); }else{ prev_alignment_model[arc.ilabel] = Plus(prev_alignment_model[arc.ilabel],arc.weight); } total = Plus( total, arc.weight ); } } return; }
void string_reader(CL_FORM *base) { LOAD_NIL(ARG(2)); LOAD_FIXNUM(ARG(3), 0, ARG(3)); COPY(SYMVAL(Slisp, 448), ARG(4)); /* *TOKEN* */ Fset_fill_pointer(ARG(3)); M1_1: ; COPY(ARG(0), ARG(3)); COPY(ARG(3), ARG(2)); LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(3)); /* T */ LOAD_NIL(ARG(4)); LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(5)); /* T */ read_char1(ARG(2)); COPY(SYMVAL(Slisp, 454), ARG(3)); /* *READTABLE* */ readtable_syntax(ARG(3)); if(CL_CHARP(ARG(2))) { } else { COPY(SYMVAL(Slisp, 58), ARG(4)); /* WRONG_TYPE */ COPY(ARG(2), ARG(5)); LOAD_SYMBOL(SYMBOL(Slisp, 18), ARG(6)); /* CHARACTER */ Ferror(ARG(4), 3); } COPY(ARG(2), ARG(4)); rt_char_code(ARG(4)); LOAD_BOOL(CL_SMVECP(ARG(3)), ARG(5)); if(CL_TRUEP(ARG(5))) { goto THEN1; } else { COPY(ARG(3), ARG(6)); LOAD_SYMBOL(SYMBOL(Slisp, 150), ARG(7)); /* COMPLEX-VECTOR */ rt_struct_typep(ARG(6)); } if(CL_TRUEP(ARG(6))) { THEN1: ; } else { COPY(SYMVAL(Slisp, 58), ARG(5)); /* WRONG_TYPE */ COPY(ARG(3), ARG(6)); LOAD_SYMBOL(SYMBOL(Slisp, 47), ARG(7)); /* VECTOR */ Ferror(ARG(5), 3); } Frow_major_aref(ARG(3)); if(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 463)) /* SINGLE-ESCAPE */ { COPY(ARG(0), ARG(3)); COPY(ARG(3), ARG(2)); LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(3)); /* T */ LOAD_NIL(ARG(4)); LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(5)); /* T */ read_char1(ARG(2)); COPY(ARG(2), ARG(3)); COPY(SYMVAL(Slisp, 448), ARG(4)); /* *TOKEN* */ LOAD_NIL(ARG(5)); vector_push_extend1(ARG(3)); } else { if(EQL(ARG(1), ARG(2))) { COPY(SYMVAL(Slisp, 448), ARG(0)); /* *TOKEN* */ LOAD_FIXNUM(ARG(1), 0, ARG(1)); LOAD_NIL(ARG(2)); subseq1(ARG(0)); goto RETURN1; } else { COPY(ARG(2), ARG(3)); COPY(SYMVAL(Slisp, 448), ARG(4)); /* *TOKEN* */ LOAD_NIL(ARG(5)); vector_push_extend1(ARG(3)); } } goto M1_1; RETURN1: ; }
void M2MFstAligner::Sequences2FST(VectorFst<LogArc> *fst, vector<string> *seq1, vector<string> *seq2) { /* Build an FST that represents all possible alignments between seq1 and seq2, given the parameter values input by the user. Here we encode the input and output labels, in fact creating a WFSA. This simplifies the training process, but means that we can only easily compute a joint maximization. In practice joint maximization seems to give the best results anyway, so it probably doesn't matter. Note: this also performs the initizization routine. It performs a UNIFORM initialization meaning that every non-null alignment sequence is eventually initialized to 1/Num(unique_alignments). It might be more appropriate to consider subsequence length here, but for now we stick to the m2m-aligner approach. TODO: Add an FST version and support for conditional maximization. May be useful for languages like Japanese where there is a distinct imbalance in the seq1->seq2 length correspondences. */ int istate = 0; int ostate = 0; for (int i = 0; i <= seq1->size(); i++) { for (int j = 0; j <= seq2->size(); j++) { fst->AddState(); istate = i * (seq2->size() + 1) + j; //Epsilon arcs for seq1 if (seq1_del == true) for (int l = 1; l <= seq2_max; l++) { if (j + l <= seq2->size()) { vector<string> subseq2(seq2->begin() + j, seq2->begin() + j + l); int is = isyms->AddSymbol(skip + s1s2_sep + vec2str(subseq2, seq2_sep)); ostate = i * (seq2->size() + 1) + (j + l); //LogArc arc( is, is, LogWeight::One().Value()*(l+1)*2, ostate ); LogArc arc(is, is, 99, ostate); //LogArc arc( is, is, LogWeight::Zero(), ostate ); fst->AddArc(istate, arc); if (prev_alignment_model.find(arc.ilabel) == prev_alignment_model.end()) prev_alignment_model.insert(pair < LogArc::Label, LogWeight > (arc.ilabel, arc.weight)); else prev_alignment_model[arc.ilabel] = Plus(prev_alignment_model[arc.ilabel], arc.weight); total = Plus(total, arc.weight); } } //Epsilon arcs for seq2 if (seq2_del == true) for (int k = 1; k <= seq1_max; k++) { if (i + k <= seq1->size()) { vector<string> subseq1(seq1->begin() + i, seq1->begin() + i + k); int is = isyms->AddSymbol(vec2str(subseq1, seq1_sep) + s1s2_sep + skip); ostate = (i + k) * (seq2->size() + 1) + j; //LogArc arc( is, is, LogWeight::One().Value()*(k+1)*2, ostate ); LogArc arc(is, is, 99, ostate); //LogArc arc( is, is, LogWeight::Zero(), ostate ); fst->AddArc(istate, arc); if (prev_alignment_model.find(arc.ilabel) == prev_alignment_model.end()) prev_alignment_model.insert(pair < LogArc::Label, LogWeight > (arc.ilabel, arc.weight)); else prev_alignment_model[arc.ilabel] = Plus(prev_alignment_model[arc.ilabel], arc.weight); total = Plus(total, arc.weight); } } //All the other arcs for (int k = 1; k <= seq1_max; k++) { for (int l = 1; l <= seq2_max; l++) { if (i + k <= seq1->size() && j + l <= seq2->size()) { vector<string> subseq1(seq1->begin() + i, seq1->begin() + i + k); string s1 = vec2str(subseq1, seq1_sep); vector<string> subseq2(seq2->begin() + j, seq2->begin() + j + l); string s2 = vec2str(subseq2, seq2_sep); if (l > 1 && k > 1) continue; int is = isyms->AddSymbol(s1 + s1s2_sep + s2); ostate = (i + k) * (seq2->size() + 1) + (j + l); LogArc arc(is, is, LogWeight::One().Value() * (k + l), ostate); //LogArc arc( is, is, LogWeight::One().Value(), ostate ); fst->AddArc(istate, arc); //During the initialization phase, just count non-eps transitions //We currently initialize to uniform probability so there is also // no need to tally anything here. if (prev_alignment_model.find(arc.ilabel) == prev_alignment_model.end()) prev_alignment_model.insert(pair < LogArc::Label, LogWeight > (arc.ilabel, arc.weight)); else prev_alignment_model[arc.ilabel] = Plus(prev_alignment_model[arc.ilabel], arc.weight); total = Plus(total, arc.weight); } } } } } fst->SetStart(0); fst->SetFinal(((seq1->size() + 1) * (seq2->size() + 1)) - 1, LogWeight::One()); //Unless seq1_del==true && seq2_del==true we will have unconnected states // thus we need to run connect to clean out these states //fst->SetInputSymbols(isyms); //fst->Write("right.nc.fsa"); if (seq1_del == false or seq2_del == false) Connect(fst); //fst->Write("right.c.fsa"); return; }
void string_capitalize1(CL_FORM *base) { COPY(ARG(0), ARG(3)); Fstring(ARG(3)); COPY(ARG(3), ARG(0)); COPY(ARG(1), ARG(3)); COPY(ARG(2), ARG(4)); COPY(ARG(0), ARG(5)); Flength(ARG(5)); check_seq_start_end(ARG(3)); COPY(ARG(3), ARG(2)); COPY(ARG(0), ARG(3)); COPY(ARG(3), ARG(4)); COPY(ARG(4), ARG(5)); LOAD_FIXNUM(ARG(6), 0, ARG(6)); LOAD_NIL(ARG(7)); subseq1(ARG(5)); COPY(ARG(5), ARG(0)); COPY(ARG(1), ARG(3)); LOAD_NIL(ARG(4)); LOAD_NIL(ARG(5)); M1_1:; COPY(ARG(3), ARG(6)); COPY(ARG(2), ARG(7)); Fnumeql(ARG(6), 2); if(CL_TRUEP(ARG(6))) { goto RETURN1; } COPY(ARG(0), ARG(6)); COPY(ARG(3), ARG(7)); if(CL_SMSTRP(ARG(6))) { } else { COPY(SYMVAL(Slisp, 58), ARG(8)); /* WRONG_TYPE */ COPY(ARG(6), ARG(9)); LOAD_SYMBOL(SYMBOL(Slisp, 40), ARG(10)); /* SIMPLE-STRING */ Ferror(ARG(8), 3); } COPY(ARG(6), ARG(8)); COPY(ARG(7), ARG(9)); COPY(ARG(9), ARG(10)); LOAD_FIXNUM(ARG(12), AR_SIZE(GET_FORM(ARG(8))), ARG(11)); F1minus(ARG(11)); if(CL_FIXNUMP(ARG(10))) { LOAD_FIXNUM(ARG(12), 0, ARG(12)); COPY(ARG(10), ARG(13)); COPY(ARG(11), ARG(14)); Fle(ARG(12), 3); } else { goto ELSE1; } if(CL_TRUEP(ARG(12))) { } else { ELSE1:; COPY(SYMVAL(Slisp, 153), ARG(10)); /* OUT_OF_RANGE */ COPY(ARG(9), ARG(11)); LOAD_FIXNUM(ARG(13), AR_SIZE(GET_FORM(ARG(8))), ARG(12)); Ferror(ARG(10), 3); } COPY(ARG(8), ARG(5)); COPY(ARG(9), ARG(6)); rt_pvref(ARG(5)); if(CL_CHARP(ARG(5))) { COPY(ARG(5), ARG(6)); } else { COPY(SYMVAL(Slisp, 58), ARG(6)); /* WRONG_TYPE */ COPY(ARG(5), ARG(7)); LOAD_SYMBOL(SYMBOL(Slisp, 18), ARG(8)); /* CHARACTER */ Ferror(ARG(6), 3); } rt_alpha_char_p(ARG(6)); if(CL_TRUEP(ARG(6))) { goto THEN2; } else { COPY(ARG(5), ARG(7)); LOAD_FIXNUM(ARG(8), 10, ARG(8)); digit_char_p1(ARG(7)); } if(CL_TRUEP(ARG(7))) { THEN2:; if(CL_TRUEP(ARG(4))) { if(CL_CHARP(ARG(5))) { COPY(ARG(5), ARG(6)); } else { COPY(SYMVAL(Slisp, 58), ARG(6)); /* WRONG_TYPE */ COPY(ARG(5), ARG(7)); LOAD_SYMBOL(SYMBOL(Slisp, 18), ARG(8)); /* CHARACTER */ Ferror(ARG(6), 3); } rt_char_downcase(ARG(6)); } else { LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(4)); /* T */ if(CL_CHARP(ARG(5))) { COPY(ARG(5), ARG(6)); } else { COPY(SYMVAL(Slisp, 58), ARG(6)); /* WRONG_TYPE */ COPY(ARG(5), ARG(7)); LOAD_SYMBOL(SYMBOL(Slisp, 18), ARG(8)); /* CHARACTER */ Ferror(ARG(6), 3); } rt_char_upcase(ARG(6)); } } else { LOAD_NIL(ARG(4)); COPY(ARG(5), ARG(6)); } COPY(ARG(6), ARG(7)); COPY(ARG(0), ARG(8)); COPY(ARG(3), ARG(9)); Fset_schar(ARG(7)); F1plus(ARG(3)); goto M1_1; RETURN1:; }
void unparse_unix_enough(CL_FORM *base) { LOAD_NIL(ARG(2)); LOAD_NIL(ARG(3)); ALLOC_CONS(ARG(4), ARG(2), ARG(3), ARG(2)); COPY(ARG(0), ARG(3)); Ppathname_directory(ARG(3)); COPY(ARG(1), ARG(4)); Ppathname_directory(ARG(4)); COPY(ARG(4), ARG(5)); Flength(ARG(5)); COPY(ARG(5), ARG(6)); LOAD_FIXNUM(ARG(7), 1, ARG(7)); Fgt(ARG(6), 2); if(CL_TRUEP(ARG(6))) { COPY(ARG(3), ARG(6)); Flength(ARG(6)); COPY(ARG(5), ARG(7)); Fge(ARG(6), 2); if(CL_TRUEP(ARG(6))) { COPY(ARG(3), ARG(6)); LOAD_FIXNUM(ARG(7), 0, ARG(7)); COPY(ARG(5), ARG(8)); subseq1(ARG(6)); COPY(ARG(4), ARG(7)); compare_component(ARG(6)); } else { goto ELSE1; } } else { goto ELSE1; } if(CL_TRUEP(ARG(6))) { LOAD_SYMBOL(SYMBOL(Slisp, 270), ARG(6)); /* RELATIVE */ COPY(ARG(5), ARG(7)); COPY(ARG(3), ARG(8)); Fnthcdr(ARG(7)); ALLOC_CONS(ARG(8), ARG(6), ARG(7), ARG(6)); } else { ELSE1:; if(CL_CONSP(ARG(3))) { COPY(GET_CAR(ARG(3)), ARG(6)); } else { if(CL_TRUEP(ARG(3))) { LOAD_SMSTR((CL_FORM *)&KClisp[264], ARG(6)); /* ~a is not a list */ COPY(ARG(3), ARG(7)); Ferror(ARG(6), 2); } else { COPY(ARG(3), ARG(6)); } } if(CL_SYMBOLP(ARG(6)) && GET_SYMBOL(ARG(6)) == SYMBOL(Slisp, 267)) /* ABSOLUTE */ { COPY(ARG(3), ARG(6)); } else { LOAD_SMSTR((CL_FORM *)&KClisp[232], ARG(6)); /* ~S cannot be represented relative to ~S */ COPY(ARG(0), ARG(7)); COPY(ARG(1), ARG(8)); Ferror(ARG(6), 3); } } COPY(ARG(6), ARG(7)); unparse_unix_directory_list(ARG(7)); COPY(ARG(2), ARG(8)); add_q(ARG(7)); COPY(ARG(0), ARG(3)); Ppathname_version(ARG(3)); if(CL_TRUEP(ARG(3))) { if(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 269)) /* NEWEST */ { LOAD_NIL(ARG(4)); } else { LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(4)); /* T */ } } else { LOAD_NIL(ARG(4)); } COPY(ARG(0), ARG(5)); Ppathname_type(ARG(5)); if(CL_TRUEP(ARG(4))) { COPY(ARG(4), ARG(6)); } else { if(CL_TRUEP(ARG(5))) { if(CL_SYMBOLP(ARG(5)) && GET_SYMBOL(ARG(5)) == SYMBOL(Slisp, 266)) /* UNSPECIFIC */ { LOAD_NIL(ARG(6)); } else { LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(6)); /* T */ } } else { LOAD_NIL(ARG(6)); } } COPY(ARG(0), ARG(7)); Ppathname_name(ARG(7)); if(CL_TRUEP(ARG(6))) { COPY(ARG(6), ARG(8)); } else { if(CL_TRUEP(ARG(7))) { COPY(ARG(7), ARG(8)); COPY(ARG(1), ARG(9)); Ppathname_name(ARG(9)); compare_component(ARG(8)); if(CL_TRUEP(ARG(8))) { LOAD_NIL(ARG(8)); } else { LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(8)); /* T */ } } else { LOAD_NIL(ARG(8)); } } if(CL_TRUEP(ARG(8))) { if(CL_TRUEP(ARG(7))) { } else { LOAD_SMSTR((CL_FORM *)&KClisp[232], ARG(9)); /* ~S cannot be represented relative to ~S */ COPY(ARG(0), ARG(10)); COPY(ARG(1), ARG(11)); Ferror(ARG(9), 3); } COPY(ARG(7), ARG(9)); unparse_unix_piece(ARG(9)); COPY(ARG(2), ARG(10)); add_q(ARG(9)); } if(CL_TRUEP(ARG(6))) { if(CL_TRUEP(ARG(5))) { LOAD_NIL(ARG(9)); } else { LOAD_SYMBOL(SYMBOL(Slisp, 48), ARG(9)); /* T */ } if(CL_TRUEP(ARG(9))) { goto THEN2; } else { } /* UNSPECIFIC */ if(CL_SYMBOLP(ARG(5)) && GET_SYMBOL(ARG(5)) == SYMBOL(Slisp, 266)) { THEN2:; LOAD_SMSTR((CL_FORM *)&KClisp[232], ARG(9)); /* ~S cannot be represented relative to ~S */ COPY(ARG(0), ARG(10)); COPY(ARG(1), ARG(11)); Ferror(ARG(9), 3); } LOAD_SMSTR((CL_FORM *)&Kunparse_unix_enough[0], ARG(9)); /* . */ COPY(ARG(2), ARG(10)); add_q(ARG(9)); COPY(ARG(5), ARG(9)); unparse_unix_piece(ARG(9)); COPY(ARG(2), ARG(10)); add_q(ARG(9)); } if(CL_TRUEP(ARG(4))) { if(CL_SYMBOLP(ARG(3)) && GET_SYMBOL(ARG(3)) == SYMBOL(Slisp, 271)) /* WILD */ { LOAD_SMSTR((CL_FORM *)&Kunparse_unix_enough[2], ARG(9)); /* .* */ COPY(ARG(2), ARG(10)); add_q(ARG(9)); } else { if(CL_FIXNUMP(ARG(3))) { LOAD_NIL(ARG(9)); LOAD_SMSTR((CL_FORM *)&Kunparse_unix_enough[4], ARG(10)); /* .~D */ COPY(ARG(3), ARG(11)); Fformat(ARG(9), 3); mv_count = 1; COPY(ARG(2), ARG(10)); add_q(ARG(9)); } else { LOAD_SMSTR((CL_FORM *)&KClisp[232], ARG(9)); /* ~S cannot be represented relative to ~S */ COPY(ARG(0), ARG(10)); COPY(ARG(1), ARG(11)); Ferror(ARG(9), 3); } } } LOAD_GLOBFUN(&CFconcatenate, ARG(3)); LOAD_SYMBOL(SYMBOL(Slisp, 40), ARG(4)); /* SIMPLE-STRING */ COPY(GET_CAR(ARG(2)), ARG(5)); Fapply(ARG(3), 3); COPY(ARG(3), ARG(0)); }