📄 mp3.lst
字号:
.................... if(*su1!=*su2)
.................... return ((*su1<*su2)??1:+1);
.................... }
.................... return 0;
.................... }
.................... /* standard template: int strcmp(const char *s1, const char *s2).
.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... signed int strcmp(char *s1, char *s2)
.................... {
.................... for (; *s1 == *s2; s1++, s2++)
.................... if (*s1 == '\0')
.................... return(0);
.................... return((*s1 < *s2) ??-1: 1);
.................... }
.................... /* standard template: int strcoll(const char *s1, const char *s2).
.................... Compares s1 & s2; returns -1 if s1<s2, 0 if s1=s2, 1 if s1>s2 */
....................
.................... signed int strcoll(char *s1, char *s2)
.................... {
.................... for (; *s1 == *s2; s1++, s2++)
.................... if (*s1 == '\0')
.................... return(0);
.................... return((*s1 < *s2) ??-1: 1);
.................... }
....................
.................... /* standard template:
.................... int strncmp(const char *s1, const char *s2, size_t n).
.................... Compares max of n characters (not following 0) from s1 to s2;
.................... returns same as strcmp */
....................
.................... signed int strncmp(char *s1, char *s2, size_t n)
.................... {
.................... for (; n > 0; s1++, s2++, n--)
.................... if (*s1 != *s2)
.................... return((*s1 <*s2) ??-1: 1);
.................... else if (*s1 == '\0')
.................... return(0);
.................... return(0);
.................... }
.................... /* standard template:
.................... int strxfrm(const char *s1, const char *s2, size_t n).
.................... transforms maximum of n characters from s2 and places them into s1*/
.................... size_t strxfrm(char *s1, char *s2, size_t n)
.................... {
.................... char *s;
.................... int n1;
.................... n1=n;
.................... for (s = s1; n > 0 && *s2 != '\0'; n--)
.................... *s++ = *s2++;
.................... for (; n > 0; n--)
.................... *s++ = '\0';
....................
.................... return(n1);
.................... }
....................
....................
....................
....................
....................
.................... /***********************************************************/
.................... /*Search functions*/
.................... /* standard template: void *memchr(const char *s, int c).
.................... Finds first occurrence of c in n characters of s */
....................
.................... char *memchr(void *s,int c,size_t n)
.................... {
.................... char uc;
.................... char *su;
.................... uc=c;
.................... for(su=s;0<n;++su,--n)
.................... if(*su==uc)
.................... return su;
.................... return NULL;
.................... }
....................
.................... /* standard template: char *strchr(const char *s, int c).
.................... Finds first occurrence of c in s */
....................
.................... char strchr(char *s, int c)
.................... {
.................... for (; *s != c; s++)
.................... if (*s == '\0')
.................... return(0);
.................... return(s);
.................... }
.................... /* standard template:
.................... size_t strcspn(const char *s1, const char *s2).
.................... Computes length of max initial segment of s1 that
.................... consists entirely of characters NOT from s2*/
....................
.................... int strcspn(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; *sc2 != 0; sc2++)
.................... if (*sc1 == *sc2)
.................... return(sc1 - s1);
.................... return(sc1 - s1);
.................... }
.................... /* standard template:
.................... char *strpbrk(const char *s1, const char *s2).
.................... Locates first occurence of any character from s2 in s1;
.................... returns s1 if s2 is empty string */
....................
.................... char strpbrk(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; *sc2 != 0; sc2++)
.................... if (*sc1 == *sc2)
.................... return(sc1);
.................... return(0);
.................... }
....................
....................
.................... /* standard template: char *strrchr(const char *s, int c).
.................... Finds last occurrence of c in s */
....................
.................... char strrchr(char *s, int c)
.................... {
.................... char *p;
....................
.................... for (p = 0; ; s++)
.................... {
.................... if (*s == c)
.................... p = s;
.................... if (*s == '\0')
.................... return(p);
.................... }
.................... }
.................... /* computes length of max initial segment of s1 consisting
.................... entirely of characters from s2 */
....................
.................... int strspn(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... for (sc1 = s1; *sc1 != 0; sc1++)
.................... for (sc2 = s2; ; sc2++)
.................... if (*sc2 == '\0')
.................... return(sc1 - s1);
.................... else if (*sc1 == *sc2)
.................... break;
.................... return(sc1 - s1);
.................... }
.................... /* standard template:
.................... char *strstr(const char *s1, const char *s2);
.................... Locates first occurence of character sequence s2 in s1;
.................... returns 0 if s2 is empty string */
....................
.................... char strstr(char *s1, char *s2)
.................... {
.................... char *sc1, *sc2;
....................
.................... if (*s2 == 0)
.................... return(s1);
.................... for (; s1 = strchr(s1, *s2); s1++)
.................... {
.................... for (sc1 = s1, sc2 = s2; ; sc1++, sc2++)
.................... if (*sc2 == 0)
.................... return(s1);
.................... else if (*sc1 != *sc2)
.................... break;
.................... }
.................... return(0);
.................... }
.................... /* standard template: char *strtok(char *s1, const char *s2).
....................
.................... Finds next token in s1 delimited by a character from separator
.................... string s2 (which can be different from call to call). First call
.................... starts at beginning of s1 searching for first character NOT
.................... contained in s2; returns 0 if none is found.
.................... If one is found, it is the start of first token (return value).
.................... Function then searches from there for a character contained in s2.
.................... If none is found, current token extends to end of s1, and subsequent
.................... searches for a token will return 0. If one is found, it is
.................... overwritten by '\0', which terminates current token. Function saves
.................... pointer to following character from which next search will start.
.................... Each subsequent call, with 0 as first argument, starts searching
.................... from saved pointer */
....................
.................... char strtok(char *s1, char *s2)
.................... {
.................... char *beg, *end;
.................... static char *save;
....................
.................... beg = (s1)??s1: save;
.................... beg += strspn(beg, s2);
.................... if (*beg == '\0')
.................... {
.................... *save = ' ';
.................... return(0);
.................... }
.................... end = strpbrk(beg, s2);
.................... if (*end != '\0')
.................... {
.................... *end = '\0';
.................... end++;
.................... }
.................... save = end;
.................... return(beg);
.................... }
....................
.................... /*****************************************************************/
.................... /*Miscellaneous functions*/
.................... /* standard template
.................... maps error number in errnum to an error message string
.................... Returns: Pointer to string
.................... */
.................... #ifdef _ERRNO
.................... char * strerror(int errnum)
.................... {
.................... char s[15];
.................... switch( errnum)
.................... {
.................... case 0:
.................... strcpy(s,"no errors");
.................... return s;
.................... case EDOM :
.................... strcpy(s,"domain error");
.................... return s;
.................... case ERANGE:
.................... strcpy(s,"range error");
.................... return s;
.................... }
.................... }
.................... #ENDIF
.................... /* standard template: size_t strlen(const char *s).
.................... Computes length of s1 (preceding terminating 0) */
....................
.................... int strlen(char *s)
.................... {
.................... char *sc;
....................
.................... for (sc = s; *sc != 0; sc++);
.................... return(sc - s);
.................... }
....................
.................... /* standard template: size_t stricmp(const char *s1, const char *s2).
.................... Compares s1 to s2 ignoring case (upper vs. lower) */
....................
.................... signed int stricmp(char *s1, char *s2)
.................... {
.................... for(; *s1==*s2||(isalpha(*s1)&&isalpha(*s2)&&(*s1==*s2+32||*s2==*s1+32));
*
36B4: MOVLB 2
36B6: MOVF xAF,W
36B8: MOVWF FE9
36BA: MOVLB 0
36BC: MOVFF 2B0,FEA
36C0: MOVFF FEF,2B3
36C4: MOVFF 2B2,03
36C8: MOVLB 2
36CA: MOVF xB1,W
36CC: MOVWF FE9
36CE: MOVLB 0
36D0: MOVFF 2B2,FEA
36D4: MOVF FEF,W
36D6: MOVLB 2
36D8: SUBWF xB3,W
36DA: BTFSC FD8.2
36DC: GOTO 37C0
36E0: MOVLB 0
36E2: MOVFF 2B0,03
36E6: MOVLB 2
36E8: MOVF xAF,W
36EA: MOVWF FE9
36EC: MOVLB 0
36EE: MOVFF 2B0,FEA
36F2: MOVFF FEF,2B4
36F6: MOVLB 2
36F8: MOVF xB4,W
36FA: SUBLW 40
36FC: BTFSC FD8.0
36FE: GOTO 370C
3702: MOVF xB4,W
3704: SUBLW 5A
3706: BTFSC FD8.0
3708: GOTO 3720
370C: MOVF xB4,W
370E: SUBLW 60
3710: BTFSC FD8.0
3712: GOTO 37FE
3716: MOVF xB4,W
3718: SUBLW 7A
371A: BTFSS FD8.0
371C: GOTO 37FE
3720: MOVLB 0
3722: MOVFF 2B2,03
3726: MOVLB 2
3728: MOVF xB1,W
372A: MOVWF FE9
372C: MOVLB 0
372E: MOVFF 2B2,FEA
3732: MOVFF FEF,2B5
3736: MOVLB 2
3738: MOVF xB5,W
373A: SUBLW 40
373C: BTFSC FD8.0
373E: GOTO 374C
3742: MOVF xB5,W
3744: SUBLW 5A
3746: BTFSC FD8.0
3748: GOTO 3760
374C: MOVF xB5,W
374E: SUBLW 60
3750: BTFSC FD8.0
3752: GOTO 37FE
3756: MOVF xB5,W
3758: SUBLW 7A
375A: BTFSS FD8.0
375C: GOTO 37FE
3760: MOVLB 0
3762: MOVLB 2
3764: MOVF xAF,W
3766: MOVWF FE9
3768: MOVLB 0
376A: MOVFF 2B0,FEA
376E: MOVFF FEF,2B6
3772: MOVFF 2B2,03
3776: MOVLB 2
3778: MOVF xB1,W
377A: MOVWF FE9
377C: MOVLB 0
377E: MOVFF 2B2,FEA
3782: MOVLW 20
3784: ADDWF FEF,W
3786: MOVLB 2
3788: SUBWF xB6,W
378A: BTFSC FD8.2
378C: GOTO 37C0
3790: MOVLB 0
3792: MOVLB 2
3794: MOVF xB1,W
3796: MOVWF FE9
3798: MOVLB 0
379A: MOVFF 2B2,FEA
379E: MOVFF FEF,2B8
37A2: MOVFF 2B0,03
37A6: MOVLB 2
37A8: MOVF xAF,W
37AA: MOVWF FE9
37AC: MOVLB 0
37AE: MOVFF 2B0,FEA
37B2: MOVLW 20
37B4: ADDWF FEF,W
37B6: MOVLB 2
37B8: SUBWF xB8,W
37BA: BTFSS FD8.2
37BC: GOTO 37FE
.................... s1++, s2++)
.................... if (*s1 == '\0')
37C0: MOVLB 0
37C2: MOVFF 2B0,03
37C6: MOVLB 2
37C8: MOVF xAF,W
37CA: MOVWF FE9
37CC: MOVLB 0
37CE: MOVFF 03,FEA
37D2: MOVF FEF,F
37D4: BTFSS FD8.2
37D6: GOTO 37E2
.................... return(0);
37DA: MOVLW 00
37DC: MOVWF 01
37DE: GOTO 383C
37E2: MOVLB 2
37E4: MOVF xB0,W
37E6: MOVWF 03
37E8: MOVF xAF,W
37EA: INCF xAF,F
37EC: BTFSC FD8.2
37EE: INCF xB0,F
37F0: INCF xB1,F
37F2: BTFSC FD8.2
37F4: INCF xB2,F
37F6: MOVLB 0
37F8: GOTO 36B4
37FC: MOVLB 2
.................... return((*s1 < *s2) ??-1: 1);
37FE: MOVLB 0
3800: MOVFF 2B0,03
3804: MOVLB 2
3806: MOVF xAF,W
3808: MOVWF FE9
380A: MOVLB 0
380C: MOVFF 2B0,FEA
3810: MOVFF FEF,2B3
3814: MOVFF 2B2,03
3818: MOVLB 2
381A: MOVF xB1,W
381C: MOVWF FE9
381E: MOVLB 0
3820: MOVFF 2B2,FEA
3824: MOVF FEF,W
3826: MOVLB 2
3828: SUBWF xB3,W
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -